diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index f0f89ca0848..62f3dc26f26 100644
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,27 @@
+2003-06-10  Phil Edwards  <pme@gcc.gnu.org>
+
+	* docs/html/17_intro/BUGS:  Update from 2.90.8 snapshot.
+	* docs/html/17_intro/CHECKLIST:  Bring up to date with respect to
+	correctness of container::iterator typedefs.  Fix whitespace.
+	* docs/html/20_util/howto.html, docs/html/ext/howto.html:  Add links
+	to allocator docs.
+	* docs/html/documentation.html:  Regenerate.
+
+	* include/bits/basic_string.h, include/bits/basic_string.tcc,
+	include/bits/deque.tcc, include/bits/list.tcc, include/bits/stl_algo.h,
+	include/bits/stl_algobase.h, include/bits/stl_bvector.h,
+	include/bits/stl_deque.h, include/bits/stl_iterator_base_funcs.h,
+	include/bits/stl_list.h, include/bits/stl_uninitialized.h,
+	include/bits/stl_vector.h, include/bits/vector.tcc,
+	include/ext/algorithm, include/ext/slist, include/std/std_bitset.h:
+	Change _Iter names to _Iterator, and __pos to __position.
+
+	* include/bits/stl_relops.h, include/bits/stl_numeric.h,
+	include/bits/stl_multiset.h, include/bits/stl_set.h:
+	Remove emacs markers.
+
+	* include/bits/stl_threads.h (_STL_auto_lock):  Add __unused__.
+
 2003-06-10  Paolo Carlini  <pcarlini@unitus.it>
 
 	* include/bits/fstream.tcc (overflow): According to
diff --git a/libstdc++-v3/docs/html/17_intro/BUGS b/libstdc++-v3/docs/html/17_intro/BUGS
index 04e4bc80623..e71304d0666 100644
--- a/libstdc++-v3/docs/html/17_intro/BUGS
+++ b/libstdc++-v3/docs/html/17_intro/BUGS
@@ -1,7 +1,4 @@
-2000-03-24 libstdc++2.90.8
-
-- testsuite/27_io/istream_extractors_char.cc: 
-  Failing on all platforms with -O2, working with -O. Need to look at this.
+2003-04-26
 
 - _GLIBCPP_HAS_BUILTIN_SINF: We should still hold out for a cleaner solution the is currenly the case in bits/std_cmath.h. 
 
diff --git a/libstdc++-v3/docs/html/17_intro/CHECKLIST b/libstdc++-v3/docs/html/17_intro/CHECKLIST
index 9d3f80d3e36..ad02b0d8731 100644
--- a/libstdc++-v3/docs/html/17_intro/CHECKLIST
+++ b/libstdc++-v3/docs/html/17_intro/CHECKLIST
@@ -1,6 +1,6 @@
 
    Completion Checklist for the Standard C++ Library
-   Updated: 1999-05-18
+   Updated: 2003-04-25
 
    Status Code Legend:
     M - Missing
@@ -17,10 +17,8 @@
    issues appear [in brackets].
 
    Note that this checklist does not (yet) include all emendations
-   recommended by the ISO Library Working Group:  (restricted site)
-     http://www.cygnus.com/iso/wp/html/fdis/lwg-issues.html
-   The LWG has announced its intention to release a public version
-   of the issues list, URL to be added here.   XXX
+   recommended by the ISO Library Working Group:
+   http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-toc.html
 
    Detailed explanation of status codes:
 
@@ -36,7 +34,7 @@
         It may have an incorrect base class, wrong namespace, wrong
         storage class, or simply not fully implement requirements.
         However, it may be sufficiently usable to help test other
-	components.
+        components.
 
     T - Implemented, pending test/inspection:  Implementation believed
         to be complete, and informal testing suggests it is ready for
@@ -49,14 +47,14 @@
         Inspected, "implementation-defined" documentation accepted,
         local usability criteria satisfied, formally inspected for
         other untestable conformance.  (Untestable requirements
-	include exception-safety, thread-safety, worst-case
-	complexity, memory cleanliness, usefulness.)
+        include exception-safety, thread-safety, worst-case
+        complexity, memory cleanliness, usefulness.)
 
     P - Portability verified:  Qualified on all primary target platforms.
 
     C - Certified:  Formally certified to have passed all tests,
         inspections, qualifications; approved under "signing authority"
-	to be used to satisfy contractual guarantees.
+        to be used to satisfy contractual guarantees.
 
    ----------------------------------------------------------------------
        <algorithm>    <iomanip>    <list>      <ostream>     <streambuf>
@@ -89,11 +87,11 @@ X   wctrans_t, wctype_t, and wint_t.
     subroutines is implementation-defined.
 
    18.1  Types                                        [lib.support.types]
-X	<cstddef>
-X	NULL
-X  	offsetof
-X	ptrdiff_t
-X	size_t
+X      <cstddef>
+X      NULL
+X      offsetof
+X      ptrdiff_t
+X      size_t
 
    18.2  Implementation properties                   [lib.support.limits]
 
@@ -101,9 +99,6 @@ X	size_t
 
    18.2.1  Numeric limits                                    [lib.limits]
 
-   [Note: the numeric_limits templates are now automatically
-    generated. ]
-
 X   template<class T> class numeric_limits;
 
 T   enum float_round_style;
@@ -192,7 +187,7 @@ T     denorm present = 1;
 
    1 Header <climits> (Table 3):
       CHAR_BIT   INT_MAX    LONG_MIN     SCHAR_MIN   UCHAR_MAX   USHRT_MAX
-X  	  CHAR_MAX   INT_MIN    MB_LEN_MAX   SHRT_MAX    UINT_MAX
+X     CHAR_MAX   INT_MIN    MB_LEN_MAX   SHRT_MAX    UINT_MAX
       CHAR_MIN   LONG_MAX   SCHAR_MAX    SHRT_MIN    ULONG_MAX
 
    3 Header <cfloat> (Table 4):
@@ -457,7 +452,7 @@ X                    |Macros:   EDOM   ERANGE   errno |
    Header <utility> synopsis
 
     // _lib.operators_, operators:
-X    namespace rel_ops {
+T    namespace rel_ops {
 T      template<class T> bool operator!=(const T&, const T&);
 T      template<class T> bool operator> (const T&, const T&);
 T      template<class T> bool operator<=(const T&, const T&);
@@ -2280,7 +2275,7 @@ X           Functions:   localeconv    setlocale
 
    Header <deque> synopsis
 
-X   template <class T, class Allocator = allocator<T> > class deque;
+T   template <class T, class Allocator = allocator<T> > class deque;
 T   template <class T, class Allocator>
       bool operator==(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
 T   template <class T, class Allocator>
@@ -2299,7 +2294,7 @@ T   template <class T, class Allocator>
 
    Header <list> synopsis
 
-X   template <class T, class Allocator = allocator<T> > class list;
+T   template <class T, class Allocator = allocator<T> > class list;
 T   template <class T, class Allocator>
       bool operator==(const list<T,Allocator>& x, const list<T,Allocator>& y);
 T   template <class T, class Allocator>
@@ -2319,7 +2314,7 @@ T   template <class T, class Allocator>
    Header <queue> synopsis
 
    namespace std {
-X   template <class T, class Container = deque<T> > class queue;
+T   template <class T, class Container = deque<T> > class queue;
 T   template <class T, class Container>
       bool operator==(const queue<T, Container>& x,
                       const queue<T, Container>& y);
@@ -2418,13 +2413,13 @@ T   template <class Allocator>
    23.2.1  Template class deque                               [lib.deque]
 
     template <class T, class Allocator = allocator<T> >
-X   class deque {
+T   class deque {
     public:
       // types:
 T     typedef typename Allocator::reference         reference;
 T     typedef typename Allocator::const_reference   const_reference;
-X     typedef implementation defined                iterator;
-X     typedef implementation defined                const_iterator;
+T     typedef implementation defined                iterator;
+T     typedef implementation defined                const_iterator;
 T     typedef implementation defined                size_type;
 T     typedef implementation defined                difference_type;
 T     typedef T                                     value_type;
@@ -2511,14 +2506,14 @@ T   template <class T, class Allocator>
 
    23.2.2  Template class list                                 [lib.list]
 
-X   template <class T, class Allocator = allocator<T> >
+T   template <class T, class Allocator = allocator<T> >
     class list {
     public:
       // types:
 T     typedef typename Allocator::reference         reference;
 T     typedef typename Allocator::const_reference   const_reference;
-X     typedef implementation defined                iterator;
-X     typedef implementation defined                const_iterator;
+T     typedef implementation defined                iterator;
+T     typedef implementation defined                const_iterator;
 T     typedef implementation defined                size_type;
 T     typedef implementation defined                difference_type;
 T     typedef T                                     value_type;
@@ -2720,13 +2715,13 @@ T   template <class T, class Container>
    23.2.4  Template class vector                             [lib.vector]
 
     template <class T, class Allocator = allocator<T> >
-X   class vector {
+T   class vector {
     public:
       // types:
 T     typedef typename Allocator::reference         reference;
 T     typedef typename Allocator::const_reference   const_reference;
-X     typedef implementation defined                iterator;
-X     typedef implementation defined                const_iterator;
+T     typedef implementation defined                iterator;
+T     typedef implementation defined                const_iterator;
 T     typedef implementation defined                size_type;
 T     typedef implementation defined                difference_type;
 T     typedef T                                     value_type;
@@ -2814,12 +2809,12 @@ T   template <class T, class Allocator>
 
    23.2.5  Class vector<bool>                           [lib.vector.bool]
 
-X   template <class Allocator> class vector<bool, Allocator> {
+T   template <class Allocator> class vector<bool, Allocator> {
     public:
       // types:
 T     typedef bool                                  const_reference;
-X     typedef implementation defined                iterator;
-X     typedef implementation defined                const_iterator;
+T     typedef implementation defined                iterator;
+T     typedef implementation defined                const_iterator;
 T     typedef implementation defined                size_type;
 T     typedef implementation defined                difference_type;
 T     typedef bool                                  value_type;
@@ -2925,7 +2920,7 @@ T   template <class Allocator>
 
     template <class Key, class T, class Compare = less<Key>,
               class Allocator = allocator<pair<const Key, T> > >
-X     class map;
+T     class map;
 
 T   template <class Key, class T, class Compare, class Allocator>
       bool operator==(const map<Key,T,Compare,Allocator>& x,
@@ -2978,7 +2973,7 @@ T   template <class Key, class T, class Compare, class Allocator>
 
     template <class Key, class Compare = less<Key>,
               class Allocator = allocator<Key> >
-X     class set;
+T     class set;
 
 T   template <class Key, class Compare, class Allocator>
       bool operator==(const set<Key,Compare,Allocator>& x,
@@ -3031,7 +3026,7 @@ T   template <class Key, class Compare, class Allocator>
 
     template <class Key, class T, class Compare = less<Key>,
               class Allocator = allocator<pair<const Key, T> > >
-X     class map {
+T     class map {
     public:
       // types:
 T     typedef Key                                   key_type;
@@ -3041,8 +3036,8 @@ T     typedef Compare                               key_compare;
 T     typedef Allocator                             allocator_type;
 T     typedef typename Allocator::reference         reference;
 T     typedef typename Allocator::const_reference   const_reference;
-X     typedef implementation defined                iterator;
-X     typedef implementation defined                const_iterator;
+T     typedef implementation defined                iterator;
+T     typedef implementation defined                const_iterator;
 T     typedef implementation defined                size_type;
 T     typedef implementation defined                difference_type;
 T     typedef typename Allocator::pointer           pointer;
@@ -3140,7 +3135,7 @@ T   template <class Key, class T, class Compare, class Allocator>
 
     template <class Key, class T, class Compare = less<Key>,
               class Allocator = allocator<pair<const Key, T> > >
-X   class multimap {
+T   class multimap {
     public:
       // types:
 T     typedef Key                                   key_type;
@@ -3150,8 +3145,8 @@ T     typedef Compare                               key_compare;
 T     typedef Allocator                             allocator_type;
 T     typedef typename Allocator::reference         reference;
 T     typedef typename Allocator::const_reference   const_reference;
-X     typedef implementation defined                iterator;
-X     typedef implementation defined                const_iterator;
+T     typedef implementation defined                iterator;
+T     typedef implementation defined                const_iterator;
 T     typedef implementation defined                size_type;
 T     typedef implementation defined                difference_type
 T     typedef typename Allocator::pointer           pointer;
@@ -3248,7 +3243,7 @@ T   template <class Key, class T, class Compare, class Allocator>
 
     template <class Key, class Compare = less<Key>,
               class Allocator = allocator<Key> >
-X   class set {
+T   class set {
     public:
       // types:
 T     typedef Key                                   key_type;
@@ -3258,8 +3253,8 @@ T     typedef Compare                               value_compare;
 T     typedef Allocator                             allocator_type;
 T     typedef typename Allocator::reference         reference;
 T     typedef typename Allocator::const_reference   const_reference;
-X     typedef implementation defined                iterator;
-X     typedef implementation defined                const_iterator;
+T     typedef implementation defined                iterator;
+T     typedef implementation defined                const_iterator;
 T     typedef implementation defined                size_type;
 T     typedef implementation defined                difference_type;
 T     typedef typename Allocator::pointer           pointer;
@@ -3338,7 +3333,7 @@ T   template <class Key, class Compare, class Allocator>
 
     template <class Key, class Compare = less<Key>,
               class Allocator = allocator<Key> >
-X   class multiset {
+T   class multiset {
     public:
       // types:
 T     typedef Key                                   key_type;
@@ -3348,8 +3343,8 @@ T     typedef Compare                               value_compare;
 T     typedef Allocator                             allocator_type;
 T     typedef typename Allocator::reference         reference;
 T     typedef typename Allocator::const_reference   const_reference;
-X     typedef implementation defined                iterator;
-X     typedef implementation defined                const_iterator;
+T     typedef implementation defined                iterator;
+T     typedef implementation defined                const_iterator;
 T     typedef implementation defined                size_type;
 T     typedef implementation defined                difference_type
 T     typedef typename Allocator::pointer           pointer;
@@ -3430,14 +3425,7 @@ T   template <class Key, class Compare, class Allocator>
 
    Header <bitset> synopsis
 
-   [What's this stuff?
-   #include <cstddef>              // for size_t
-   #include <string>
-   #include <stdexcept>            // for invalid_argument,
-                                  //     out_of_range, overflow_error
-   #include <iosfwd>               // for istream, ostream
-   ]
-X   template <size_t N> class bitset;
+T   template <size_t N> class bitset;
     // _lib.bitset.operators_ bitset operations:
 T   template <size_t N>
       bitset<N> operator&(const bitset<N>&, const bitset<N>&);
@@ -3452,7 +3440,7 @@ T   template <class charT, class traits, size_t N>
       basic_ostream<charT, traits>&
       operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x);
 
-X   template<size_t N> class bitset {
+T   template<size_t N> class bitset {
     public:
       // bit reference:
 T     class reference {
diff --git a/libstdc++-v3/docs/html/20_util/howto.html b/libstdc++-v3/docs/html/20_util/howto.html
index 9952849c0fb..af40bceae0e 100644
--- a/libstdc++-v3/docs/html/20_util/howto.html
+++ b/libstdc++-v3/docs/html/20_util/howto.html
@@ -30,6 +30,7 @@
    <li><a href="#2"><code>auto_ptr</code> inside container classes</a></li>
    <li><a href="#3">Functors</a></li>
    <li><a href="#4">Pairs</a></li>
+   <li><a href="#5">Memory allocators</a></li>
 </ul>
 
 <hr />
@@ -207,7 +208,14 @@
       <a href="../faq/index.html">to the FAQ</a>.
    </p>
 
-
+<hr />
+<h2><a name="5">Memory allocators</a></h2>
+   <p>The available free store (&quot;heap&quot;) management classes are
+      described <a href="../ext/howto.html">here</a>.
+   </p>
+   <p>Return <a href="#top">to top of page</a> or
+      <a href="../faq/index.html">to the FAQ</a>.
+   </p>
 
 
 <!-- ####################################################### -->
diff --git a/libstdc++-v3/docs/html/documentation.html b/libstdc++-v3/docs/html/documentation.html
index 778999d9687..68f79f7f3c4 100644
--- a/libstdc++-v3/docs/html/documentation.html
+++ b/libstdc++-v3/docs/html/documentation.html
@@ -143,6 +143,7 @@
      <li><a href="20_util/howto.html#2"><code>auto_ptr</code> inside container classes</a></li>
      <li><a href="20_util/howto.html#3">Functors</a></li>
      <li><a href="20_util/howto.html#4">Pairs</a></li>
+     <li><a href="20_util/howto.html#5">Memory allocators</a></li>
    </ul>
    </li>
 
@@ -222,8 +223,8 @@
    <ul>
      <li><a href="ext/howto.html#1">Ropes and trees and hashes, oh my!</a></li>
      <li><a href="ext/howto.html#2">Added members and types</a></li>
-     <li><a href="ext/howto.html#3">Allocators (versions 3.0, 3.1, 3.2)</a></li>
-     <li><a href="ext/howto.html#6">Allocators (version 3.3)</a></li>
+     <li><a href="ext/howto.html#3">Allocators (versions 3.0, 3.1, 3.2, 3.3)</a></li>
+     <li><a href="ext/howto.html#6">Allocators (version 3.4)</a></li>
      <li><a href="ext/howto.html#4">Compile-time checks</a></li>
      <li><a href="ext/howto.html#5">LWG Issues</a></li>
      <li><a href="ext/../18_support/howto.html#5">Demangling</a></li>
diff --git a/libstdc++-v3/docs/html/ext/howto.html b/libstdc++-v3/docs/html/ext/howto.html
index 1fa80ad8f80..3289619625c 100644
--- a/libstdc++-v3/docs/html/ext/howto.html
+++ b/libstdc++-v3/docs/html/ext/howto.html
@@ -41,8 +41,8 @@
 <ul>
    <li><a href="#1">Ropes and trees and hashes, oh my!</a></li>
    <li><a href="#2">Added members and types</a></li>
-   <li><a href="#3">Allocators (versions 3.0, 3.1, 3.2)</a></li>
-   <li><a href="#6">Allocators (version 3.3)</a></li>
+   <li><a href="#3">Allocators (versions 3.0, 3.1, 3.2, 3.3)</a></li>
+   <li><a href="#6">Allocators (version 3.4)</a></li>
    <li><a href="#4">Compile-time checks</a></li>
    <li><a href="#5">LWG Issues</a></li>
    <li><a href="../18_support/howto.html#5">Demangling</a></li>
@@ -134,7 +134,7 @@
    </p>
 
 <hr />
-<h2><a name="3">Allocators (versions 3.0, 3.1, 3.2)</a></h2>
+<h2><a name="3">Allocators (versions 3.0, 3.1, 3.2, 3.3)</a></h2>
    <p>Thread-safety, space efficiency, high speed, portability... this is a
       mess.  Where to begin?
    </p>
@@ -361,9 +361,14 @@
    </p>
 
 <hr />
-<h2><a name="6">Allocators (version 3.3)</a></h2>
+<h2><a name="6">Allocators (version 3.4)</a></h2>
    <p>Changes are coming...
    </p>
+   <p>If you plan on writing your own allocators,
+      <a href="../documentation.html#4">source documentation</a> is
+      available.  You'll need to get the &quot;maintainers&quot; collection
+      in order to see the helper classes and extra notes.
+   </p>
    <p>Return <a href="#top">to top of page</a> or
       <a href="../faq/index.html">to the FAQ</a>.
    </p>
diff --git a/libstdc++-v3/include/bits/basic_string.h b/libstdc++-v3/include/bits/basic_string.h
index b4658d640c2..968d4cae526 100644
--- a/libstdc++-v3/include/bits/basic_string.h
+++ b/libstdc++-v3/include/bits/basic_string.h
@@ -661,43 +661,43 @@ namespace std
 
       // _S_construct_aux is used to implement the 21.3.1 para 15 which
       // requires special behaviour if _InIter is an integral type
-      template<class _InIter>
+      template<class _InIterator>
         static _CharT*
-        _S_construct_aux(_InIter __beg, _InIter __end, const _Alloc& __a,
+        _S_construct_aux(_InIterator __beg, _InIterator __end, const _Alloc& __a,
 			 __false_type)
 	{
-          typedef typename iterator_traits<_InIter>::iterator_category _Tag;
+          typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
           return _S_construct(__beg, __end, __a, _Tag());
 	}
 
-      template<class _InIter>
+      template<class _InIterator>
         static _CharT*
-        _S_construct_aux(_InIter __beg, _InIter __end, const _Alloc& __a,
+        _S_construct_aux(_InIterator __beg, _InIterator __end, const _Alloc& __a,
 			 __true_type)
 	{
 	  return _S_construct(static_cast<size_type>(__beg),
 			      static_cast<value_type>(__end), __a);
 	}
 
-      template<class _InIter>
+      template<class _InIterator>
         static _CharT*
-        _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a)
+        _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
 	{
-	  typedef typename _Is_integer<_InIter>::_Integral _Integral;
+	  typedef typename _Is_integer<_InIterator>::_Integral _Integral;
 	  return _S_construct_aux(__beg, __end, __a, _Integral());
         }
 
       // For Input Iterators, used in istreambuf_iterators, etc.
-      template<class _InIter>
+      template<class _InIterator>
         static _CharT*
-         _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a,
+         _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
 		      input_iterator_tag);
 
       // For forward_iterators up to random_access_iterators, used for
       // string::iterator, _CharT*, etc.
-      template<class _FwdIter>
+      template<class _FwdIterator>
         static _CharT*
-        _S_construct(_FwdIter __beg, _FwdIter __end, const _Alloc& __a,
+        _S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
 		     forward_iterator_tag);
 
       static _CharT*
diff --git a/libstdc++-v3/include/bits/basic_string.tcc b/libstdc++-v3/include/bits/basic_string.tcc
index 9d2826dedc1..3855eff9882 100644
--- a/libstdc++-v3/include/bits/basic_string.tcc
+++ b/libstdc++-v3/include/bits/basic_string.tcc
@@ -71,10 +71,10 @@ namespace std
   // Input Iterators have a cost structure very different from
   // pointers, calling for a different coding style.
   template<typename _CharT, typename _Traits, typename _Alloc>
-    template<typename _InIter>
+    template<typename _InIterator>
       _CharT*
       basic_string<_CharT, _Traits, _Alloc>::
-      _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a,
+      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
 		   input_iterator_tag)
       {
 	if (__beg == __end && __a == _Alloc())
@@ -131,17 +131,17 @@ namespace std
       }
   
   template<typename _CharT, typename _Traits, typename _Alloc>
-    template <class _InIter>
+    template <class _InIterator>
       _CharT*
       basic_string<_CharT, _Traits, _Alloc>::
-      _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a, 
+      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a, 
 		   forward_iterator_tag)
       {
 	if (__beg == __end && __a == _Alloc())
 	  return _S_empty_rep()._M_refcopy();
 
 	// NB: Not required, but considered best practice.
-	if (__builtin_expect(__beg == _InIter(), 0))
+	if (__builtin_expect(__beg == _InIterator(), 0))
 	  __throw_logic_error("basic_string::_S_construct NULL not valid");
 
 	const size_type __dnew = static_cast<size_type>(std::distance(__beg, __end));
@@ -234,9 +234,9 @@ namespace std
     { }
  
   template<typename _CharT, typename _Traits, typename _Alloc>
-    template<typename _InputIter>
+    template<typename _InputIterator>
     basic_string<_CharT, _Traits, _Alloc>::
-    basic_string(_InputIter __beg, _InputIter __end, const _Alloc& __a)
+    basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a)
     : _M_dataplus(_S_construct(__beg, __end, __a), __a)
     { }
 
@@ -613,11 +613,11 @@ namespace std
   // for input iterators and reverse iterators. It buffers internally and then
   // calls _M_replace_safe.
   template<typename _CharT, typename _Traits, typename _Alloc>
-    template<typename _InputIter>
+    template<typename _InputIterator>
       basic_string<_CharT, _Traits, _Alloc>&
       basic_string<_CharT, _Traits, _Alloc>::
-      _M_replace(iterator __i1, iterator __i2, _InputIter __k1, 
-		 _InputIter __k2, input_iterator_tag)
+      _M_replace(iterator __i1, iterator __i2, _InputIterator __k1, 
+		 _InputIterator __k2, input_iterator_tag)
       {
 	// Save concerned source string data in a temporary.
 	const basic_string __s(__k1, __k2);
@@ -628,11 +628,11 @@ namespace std
   // and can be used in "safe" situations involving forward iterators,
   // i.e., when source and destination ranges are known to not overlap.
   template<typename _CharT, typename _Traits, typename _Alloc>
-    template<typename _ForwardIter>
+    template<typename _ForwardIterator>
       basic_string<_CharT, _Traits, _Alloc>&
       basic_string<_CharT, _Traits, _Alloc>::
-      _M_replace_safe(iterator __i1, iterator __i2, _ForwardIter __k1, 
-		      _ForwardIter __k2)
+      _M_replace_safe(iterator __i1, iterator __i2, _ForwardIterator __k1, 
+		      _ForwardIterator __k2)
       {
 	const size_type __dnew = static_cast<size_type>(std::distance(__k1, __k2));
 	const size_type __dold = __i2 - __i1;
diff --git a/libstdc++-v3/include/bits/deque.tcc b/libstdc++-v3/include/bits/deque.tcc
index d4143f4f155..7e3b21efe04 100644
--- a/libstdc++-v3/include/bits/deque.tcc
+++ b/libstdc++-v3/include/bits/deque.tcc
@@ -186,10 +186,10 @@ namespace std
     }
     
   template <typename _Tp, class _Alloc>
-    template <typename _InputIter>
+    template <typename _InputIterator>
       void
       deque<_Tp,_Alloc>
-      ::_M_assign_aux(_InputIter __first, _InputIter __last, input_iterator_tag)
+      ::_M_assign_aux(_InputIterator __first, _InputIterator __last, input_iterator_tag)
       {
         iterator __cur = begin();
         for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
@@ -710,4 +710,3 @@ namespace std
 } // namespace std 
   
 #endif /* __GLIBCPP_INTERNAL_DEQUE_TCC */
-
diff --git a/libstdc++-v3/include/bits/list.tcc b/libstdc++-v3/include/bits/list.tcc
index e4d47a2bb37..95a74273155 100644
--- a/libstdc++-v3/include/bits/list.tcc
+++ b/libstdc++-v3/include/bits/list.tcc
@@ -160,10 +160,10 @@ namespace std
     }
   
   template<typename _Tp, typename _Alloc>
-    template <typename _InputIter>
+    template <typename _InputIterator>
       void
       list<_Tp,_Alloc>::
-      _M_assign_dispatch(_InputIter __first2, _InputIter __last2, __false_type)
+      _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2, __false_type)
       {
         iterator __first1 = begin();
         iterator __last1 = end();
diff --git a/libstdc++-v3/include/bits/stl_algo.h b/libstdc++-v3/include/bits/stl_algo.h
index ea5722ea7e7..ac15b3afcbf 100644
--- a/libstdc++-v3/include/bits/stl_algo.h
+++ b/libstdc++-v3/include/bits/stl_algo.h
@@ -147,12 +147,12 @@ namespace std
    *  @p [first,last).  @p f must not modify the order of the sequence.
    *  If @p f has a return value it is ignored.
   */
-  template<typename _InputIter, typename _Function>
+  template<typename _InputIterator, typename _Function>
     _Function
-    for_each(_InputIter __first, _InputIter __last, _Function __f)
+    for_each(_InputIterator __first, _InputIterator __last, _Function __f)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
       for ( ; __first != __last; ++__first)
 	__f(*__first);
       return __f;
@@ -163,9 +163,9 @@ namespace std
    *  This is an overload used by find() for the Input Iterator case.
    *  @endif
   */
-  template<typename _InputIter, typename _Tp>
-    inline _InputIter
-    find(_InputIter __first, _InputIter __last,
+  template<typename _InputIterator, typename _Tp>
+    inline _InputIterator
+    find(_InputIterator __first, _InputIterator __last,
 	 const _Tp& __val,
 	 input_iterator_tag)
     {
@@ -179,9 +179,9 @@ namespace std
    *  This is an overload used by find_if() for the Input Iterator case.
    *  @endif
   */
-  template<typename _InputIter, typename _Predicate>
-    inline _InputIter
-    find_if(_InputIter __first, _InputIter __last,
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    find_if(_InputIterator __first, _InputIterator __last,
 	    _Predicate __pred,
 	    input_iterator_tag)
     {
@@ -195,13 +195,13 @@ namespace std
    *  This is an overload used by find() for the RAI case.
    *  @endif
   */
-  template<typename _RandomAccessIter, typename _Tp>
-    _RandomAccessIter
-    find(_RandomAccessIter __first, _RandomAccessIter __last,
+  template<typename _RandomAccessIterator, typename _Tp>
+    _RandomAccessIterator
+    find(_RandomAccessIterator __first, _RandomAccessIterator __last,
 	 const _Tp& __val,
 	 random_access_iterator_tag)
     {
-      typename iterator_traits<_RandomAccessIter>::difference_type __trip_count
+      typename iterator_traits<_RandomAccessIterator>::difference_type __trip_count
 	= (__last - __first) >> 2;
 
       for ( ; __trip_count > 0 ; --__trip_count) {
@@ -239,13 +239,13 @@ namespace std
    *  This is an overload used by find_if() for the RAI case.
    *  @endif
   */
-  template<typename _RandomAccessIter, typename _Predicate>
-    _RandomAccessIter
-    find_if(_RandomAccessIter __first, _RandomAccessIter __last,
+  template<typename _RandomAccessIterator, typename _Predicate>
+    _RandomAccessIterator
+    find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
 	    _Predicate __pred,
 	    random_access_iterator_tag)
     {
-      typename iterator_traits<_RandomAccessIter>::difference_type __trip_count
+      typename iterator_traits<_RandomAccessIterator>::difference_type __trip_count
 	= (__last - __first) >> 2;
 
       for ( ; __trip_count > 0 ; --__trip_count) {
@@ -286,15 +286,15 @@ namespace std
    *  @return   The first iterator @c i in the range @p [first,last)
    *  such that @c *i == @p val, or @p last if no such iterator exists.
   */
-  template<typename _InputIter, typename _Tp>
-    inline _InputIter
-    find(_InputIter __first, _InputIter __last,
+  template<typename _InputIterator, typename _Tp>
+    inline _InputIterator
+    find(_InputIterator __first, _InputIterator __last,
 	 const _Tp& __val)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
       __glibcpp_function_requires(_EqualOpConcept<
-		typename iterator_traits<_InputIter>::value_type, _Tp>)
+		typename iterator_traits<_InputIterator>::value_type, _Tp>)
       return find(__first, __last, __val, __iterator_category(__first));
     }
 
@@ -306,15 +306,15 @@ namespace std
    *  @return   The first iterator @c i in the range @p [first,last)
    *  such that @p pred(*i) is true, or @p last if no such iterator exists.
   */
-  template<typename _InputIter, typename _Predicate>
-    inline _InputIter
-    find_if(_InputIter __first, _InputIter __last,
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    find_if(_InputIterator __first, _InputIterator __last,
 	    _Predicate __pred)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
       __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
-	      typename iterator_traits<_InputIter>::value_type>)
+	      typename iterator_traits<_InputIterator>::value_type>)
       return find_if(__first, __last, __pred, __iterator_category(__first));
     }
 
@@ -326,17 +326,17 @@ namespace std
    *  valid iterators in @p [first,last) and such that @c *i == @c *(i+1),
    *  or @p last if no such iterator exists.
   */
-  template<typename _ForwardIter>
-    _ForwardIter
-    adjacent_find(_ForwardIter __first, _ForwardIter __last)
+  template<typename _ForwardIterator>
+    _ForwardIterator
+    adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_EqualityComparableConcept<
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_ForwardIterator>::value_type>)
       if (__first == __last)
 	return __last;
-      _ForwardIter __next = __first;
+      _ForwardIterator __next = __first;
       while(++__next != __last) {
 	if (*__first == *__next)
 	  return __first;
@@ -355,19 +355,19 @@ namespace std
    *  @p binary_pred(*i,*(i+1)) is true, or @p last if no such iterator
    *  exists.
   */
-  template<typename _ForwardIter, typename _BinaryPredicate>
-    _ForwardIter
-    adjacent_find(_ForwardIter __first, _ForwardIter __last,
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    _ForwardIterator
+    adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
 		  _BinaryPredicate __binary_pred)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
-	    typename iterator_traits<_ForwardIter>::value_type,
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_ForwardIterator>::value_type,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
       if (__first == __last)
 	return __last;
-      _ForwardIter __next = __first;
+      _ForwardIterator __next = __first;
       while(++__next != __last) {
 	if (__binary_pred(*__first, *__next))
 	  return __first;
@@ -384,16 +384,16 @@ namespace std
    *  @return   The number of iterators @c i in the range @p [first,last)
    *  for which @c *i == @p value
   */
-  template<typename _InputIter, typename _Tp>
-    typename iterator_traits<_InputIter>::difference_type
-    count(_InputIter __first, _InputIter __last, const _Tp& __value)
+  template<typename _InputIterator, typename _Tp>
+    typename iterator_traits<_InputIterator>::difference_type
+    count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
       __glibcpp_function_requires(_EqualityComparableConcept<
-	    typename iterator_traits<_InputIter>::value_type >)
+	    typename iterator_traits<_InputIterator>::value_type >)
       __glibcpp_function_requires(_EqualityComparableConcept<_Tp>)
-      typename iterator_traits<_InputIter>::difference_type __n = 0;
+      typename iterator_traits<_InputIterator>::difference_type __n = 0;
       for ( ; __first != __last; ++__first)
 	if (*__first == __value)
 	  ++__n;
@@ -408,15 +408,15 @@ namespace std
    *  @return   The number of iterators @c i in the range @p [first,last)
    *  for which @p pred(*i) is true.
   */
-  template<typename _InputIter, typename _Predicate>
-    typename iterator_traits<_InputIter>::difference_type
-    count_if(_InputIter __first, _InputIter __last, _Predicate __pred)
+  template<typename _InputIterator, typename _Predicate>
+    typename iterator_traits<_InputIterator>::difference_type
+    count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
       __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
-	    typename iterator_traits<_InputIter>::value_type>)
-      typename iterator_traits<_InputIter>::difference_type __n = 0;
+	    typename iterator_traits<_InputIterator>::value_type>)
+      typename iterator_traits<_InputIterator>::difference_type __n = 0;
       for ( ; __first != __last; ++__first)
 	if (__pred(*__first))
 	  ++__n;
@@ -447,35 +447,35 @@ namespace std
    *  This means that the returned iterator @c i will be in the range
    *  @p [first1,last1-(last2-first2))
   */
-  template<typename _ForwardIter1, typename _ForwardIter2>
-    _ForwardIter1
-    search(_ForwardIter1 __first1, _ForwardIter1 __last1,
-	   _ForwardIter2 __first2, _ForwardIter2 __last2)
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    _ForwardIterator1
+    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+	   _ForwardIterator2 __first2, _ForwardIterator2 __last2)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>)
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
       __glibcpp_function_requires(_EqualOpConcept<
-	    typename iterator_traits<_ForwardIter1>::value_type,
-	    typename iterator_traits<_ForwardIter2>::value_type>)
+	    typename iterator_traits<_ForwardIterator1>::value_type,
+	    typename iterator_traits<_ForwardIterator2>::value_type>)
 
       // Test for empty ranges
       if (__first1 == __last1 || __first2 == __last2)
 	return __first1;
 
       // Test for a pattern of length 1.
-      _ForwardIter2 __tmp(__first2);
+      _ForwardIterator2 __tmp(__first2);
       ++__tmp;
       if (__tmp == __last2)
 	return find(__first1, __last1, *__first2);
 
       // General case.
 
-      _ForwardIter2 __p1, __p;
+      _ForwardIterator2 __p1, __p;
 
       __p1 = __first2; ++__p1;
 
-      _ForwardIter1 __current = __first1;
+      _ForwardIterator1 __current = __first1;
 
       while (__first1 != __last1) {
 	__first1 = find(__first1, __last1, *__first2);
@@ -519,25 +519,25 @@ namespace std
    *
    *  @see search(_ForwardIter1, _ForwardIter1, _ForwardIter2, _ForwardIter2)
   */
-  template<typename _ForwardIter1, typename _ForwardIter2, typename _BinaryPred>
-    _ForwardIter1
-    search(_ForwardIter1 __first1, _ForwardIter1 __last1,
-	   _ForwardIter2 __first2, _ForwardIter2 __last2,
-	   _BinaryPred  __predicate)
+  template<typename _ForwardIterator1, typename _ForwardIterator2, typename _BinaryPredicate>
+    _ForwardIterator1
+    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+	   _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+	   _BinaryPredicate  __predicate)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>)
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>)
-      __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPred,
-	    typename iterator_traits<_ForwardIter1>::value_type,
-	    typename iterator_traits<_ForwardIter2>::value_type>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
+      __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
+	    typename iterator_traits<_ForwardIterator1>::value_type,
+	    typename iterator_traits<_ForwardIterator2>::value_type>)
 
       // Test for empty ranges
       if (__first1 == __last1 || __first2 == __last2)
 	return __first1;
 
       // Test for a pattern of length 1.
-      _ForwardIter2 __tmp(__first2);
+      _ForwardIterator2 __tmp(__first2);
       ++__tmp;
       if (__tmp == __last2) {
 	while (__first1 != __last1 && !__predicate(*__first1, *__first2))
@@ -547,11 +547,11 @@ namespace std
 
       // General case.
 
-      _ForwardIter2 __p1, __p;
+      _ForwardIterator2 __p1, __p;
 
       __p1 = __first2; ++__p1;
 
-      _ForwardIter1 __current = __first1;
+      _ForwardIterator1 __current = __first1;
 
       while (__first1 != __last1) {
 	while (__first1 != __last1) {
@@ -593,15 +593,15 @@ namespace std
    *  Searches the range @p [first,last) for @p count consecutive elements
    *  equal to @p val.
   */
-  template<typename _ForwardIter, typename _Integer, typename _Tp>
-    _ForwardIter
-    search_n(_ForwardIter __first, _ForwardIter __last,
+  template<typename _ForwardIterator, typename _Integer, typename _Tp>
+    _ForwardIterator
+    search_n(_ForwardIterator __first, _ForwardIterator __last,
 	     _Integer __count, const _Tp& __val)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_EqualityComparableConcept<
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_ForwardIterator>::value_type>)
       __glibcpp_function_requires(_EqualityComparableConcept<_Tp>)
 
       if (__count <= 0)
@@ -610,7 +610,7 @@ namespace std
 	__first = find(__first, __last, __val);
 	while (__first != __last) {
 	  _Integer __n = __count - 1;
-	  _ForwardIter __i = __first;
+	  _ForwardIterator __i = __first;
 	  ++__i;
 	  while (__i != __last && __n != 0 && *__i == __val) {
 	    ++__i;
@@ -640,17 +640,17 @@ namespace std
    *  Searches the range @p [first,last) for @p count consecutive elements
    *  for which the predicate returns true.
   */
-  template<typename _ForwardIter, typename _Integer, typename _Tp,
-           typename _BinaryPred>
-    _ForwardIter
-    search_n(_ForwardIter __first, _ForwardIter __last,
+  template<typename _ForwardIterator, typename _Integer, typename _Tp,
+           typename _BinaryPredicate>
+    _ForwardIterator
+    search_n(_ForwardIterator __first, _ForwardIterator __last,
 	     _Integer __count, const _Tp& __val,
-	     _BinaryPred __binary_pred)
+	     _BinaryPredicate __binary_pred)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
-      __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPred,
-	    typename iterator_traits<_ForwardIter>::value_type, _Tp>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
+	    typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
 
       if (__count <= 0)
 	return __first;
@@ -662,7 +662,7 @@ namespace std
 	}
 	while (__first != __last) {
 	  _Integer __n = __count - 1;
-	  _ForwardIter __i = __first;
+	  _ForwardIterator __i = __first;
 	  ++__i;
 	  while (__i != __last && __n != 0 && __binary_pred(*__i, __val)) {
 	    ++__i;
@@ -694,20 +694,20 @@ namespace std
    *  corresponding element in the range @p [first2,(last1-first1)).
    *  The ranges must not overlap.
   */
-  template<typename _ForwardIter1, typename _ForwardIter2>
-    _ForwardIter2
-    swap_ranges(_ForwardIter1 __first1, _ForwardIter1 __last1,
-		_ForwardIter2 __first2)
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    _ForwardIterator2
+    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+		_ForwardIterator2 __first2)
     {
       // concept requirements
-      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter1>)
-      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter2>)
+      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator1>)
+      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator2>)
       __glibcpp_function_requires(_ConvertibleConcept<
-	    typename iterator_traits<_ForwardIter1>::value_type,
-	    typename iterator_traits<_ForwardIter2>::value_type>)
+	    typename iterator_traits<_ForwardIterator1>::value_type,
+	    typename iterator_traits<_ForwardIterator2>::value_type>)
       __glibcpp_function_requires(_ConvertibleConcept<
-	    typename iterator_traits<_ForwardIter2>::value_type,
-	    typename iterator_traits<_ForwardIter1>::value_type>)
+	    typename iterator_traits<_ForwardIterator2>::value_type,
+	    typename iterator_traits<_ForwardIterator1>::value_type>)
 
       for ( ; __first1 != __last1; ++__first1, ++__first2)
 	iter_swap(__first1, __first2);
@@ -729,14 +729,14 @@ namespace std
    *
    *  @p unary_op must not alter its argument.
   */
-  template<typename _InputIter, typename _OutputIter, typename _UnaryOperation>
-    _OutputIter
-    transform(_InputIter __first, _InputIter __last,
-	      _OutputIter __result, _UnaryOperation __unary_op)
+  template<typename _InputIterator, typename _OutputIterator, typename _UnaryOperation>
+    _OutputIterator
+    transform(_InputIterator __first, _InputIterator __last,
+	      _OutputIterator __result, _UnaryOperation __unary_op)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
             // "the type returned by a _UnaryOperation"
             __typeof__(__unary_op(*__first))>)
 
@@ -762,17 +762,17 @@ namespace std
    *
    *  @p binary_op must not alter either of its arguments.
   */
-  template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
+  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
 	   typename _BinaryOperation>
-    _OutputIter
-    transform(_InputIter1 __first1, _InputIter1 __last1,
-	      _InputIter2 __first2, _OutputIter __result,
+    _OutputIterator
+    transform(_InputIterator1 __first1, _InputIterator1 __last1,
+	      _InputIterator2 __first2, _OutputIterator __result,
 	      _BinaryOperation __binary_op)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
             // "the type returned by a _BinaryOperation"
             __typeof__(__binary_op(*__first1,*__first2))>)
 
@@ -793,17 +793,17 @@ namespace std
    *  For each iterator @c i in the range @p [first,last) if @c *i ==
    *  @p old_value then the assignment @c *i = @p new_value is performed.
   */
-  template<typename _ForwardIter, typename _Tp>
+  template<typename _ForwardIterator, typename _Tp>
     void
-    replace(_ForwardIter __first, _ForwardIter __last,
+    replace(_ForwardIterator __first, _ForwardIterator __last,
 	    const _Tp& __old_value, const _Tp& __new_value)
     {
       // concept requirements
-      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_EqualOpConcept<
-	    typename iterator_traits<_ForwardIter>::value_type, _Tp>)
+	    typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
       __glibcpp_function_requires(_ConvertibleConcept<_Tp,
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_ForwardIterator>::value_type>)
 
       for ( ; __first != __last; ++__first)
 	if (*__first == __old_value)
@@ -822,17 +822,17 @@ namespace std
    *  For each iterator @c i in the range @p [first,last) if @p pred(*i)
    *  is true then the assignment @c *i = @p new_value is performed.
   */
-  template<typename _ForwardIter, typename _Predicate, typename _Tp>
+  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
     void
-    replace_if(_ForwardIter __first, _ForwardIter __last,
+    replace_if(_ForwardIterator __first, _ForwardIterator __last,
 	       _Predicate __pred, const _Tp& __new_value)
     {
       // concept requirements
-      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_ConvertibleConcept<_Tp,
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_ForwardIterator>::value_type>)
       __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_ForwardIterator>::value_type>)
 
       for ( ; __first != __last; ++__first)
 	if (__pred(*__first))
@@ -853,18 +853,18 @@ namespace std
    *  output range @p [result,result+(last-first)) replacing elements
    *  equal to @p old_value with @p new_value.
   */
-  template<typename _InputIter, typename _OutputIter, typename _Tp>
-    _OutputIter
-    replace_copy(_InputIter __first, _InputIter __last,
-		 _OutputIter __result,
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+    _OutputIterator
+    replace_copy(_InputIterator __first, _InputIterator __last,
+		 _OutputIterator __result,
 		 const _Tp& __old_value, const _Tp& __new_value)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-	    typename iterator_traits<_InputIter>::value_type>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator>::value_type>)
       __glibcpp_function_requires(_EqualOpConcept<
-	    typename iterator_traits<_InputIter>::value_type, _Tp>)
+	    typename iterator_traits<_InputIterator>::value_type, _Tp>)
 
       for ( ; __first != __last; ++__first, ++__result)
 	*__result = *__first == __old_value ? __new_value : *__first;
@@ -885,19 +885,19 @@ namespace std
    *  @p [result,result+(last-first)) replacing elements for which
    *  @p pred returns true with @p new_value.
   */
-  template<typename _InputIter, typename _OutputIter, typename _Predicate,
+  template<typename _InputIterator, typename _OutputIterator, typename _Predicate,
            typename _Tp>
-    _OutputIter
-    replace_copy_if(_InputIter __first, _InputIter __last,
-		    _OutputIter __result,
+    _OutputIterator
+    replace_copy_if(_InputIterator __first, _InputIterator __last,
+		    _OutputIterator __result,
 		    _Predicate __pred, const _Tp& __new_value)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-	    typename iterator_traits<_InputIter>::value_type>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator>::value_type>)
       __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
-	    typename iterator_traits<_InputIter>::value_type>)
+	    typename iterator_traits<_InputIterator>::value_type>)
 
       for ( ; __first != __last; ++__first, ++__result)
 	*__result = __pred(*__first) ? __new_value : *__first;
@@ -915,14 +915,14 @@ namespace std
    *  Performs the assignment @c *i = @p gen() for each @c i in the range
    *  @p [first,last).
   */
-  template<typename _ForwardIter, typename _Generator>
+  template<typename _ForwardIterator, typename _Generator>
     void
-    generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen)
+    generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_GeneratorConcept<_Generator,
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_ForwardIterator>::value_type>)
 
       for ( ; __first != __last; ++__first)
 	*__first = __gen();
@@ -939,12 +939,12 @@ namespace std
    *  Performs the assignment @c *i = @p gen() for each @c i in the range
    *  @p [first,first+n).
   */
-  template<typename _OutputIter, typename _Size, typename _Generator>
-    _OutputIter
-    generate_n(_OutputIter __first, _Size __n, _Generator __gen)
+  template<typename _OutputIterator, typename _Size, typename _Generator>
+    _OutputIterator
+    generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
     {
       // concept requirements
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
             // "the type returned by a _Generator"
             __typeof__(gen())>)
 
@@ -966,17 +966,17 @@ namespace std
    *  remove_copy() is stable, so the relative order of elements that are
    *  copied is unchanged.
   */
-  template<typename _InputIter, typename _OutputIter, typename _Tp>
-    _OutputIter
-    remove_copy(_InputIter __first, _InputIter __last,
-		_OutputIter __result, const _Tp& __value)
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+    _OutputIterator
+    remove_copy(_InputIterator __first, _InputIterator __last,
+		_OutputIterator __result, const _Tp& __value)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-	    typename iterator_traits<_InputIter>::value_type>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator>::value_type>)
       __glibcpp_function_requires(_EqualOpConcept<
-	    typename iterator_traits<_InputIter>::value_type, _Tp>)
+	    typename iterator_traits<_InputIterator>::value_type, _Tp>)
 
       for ( ; __first != __last; ++__first)
 	if (!(*__first == __value)) {
@@ -1000,17 +1000,17 @@ namespace std
    *  remove_copy_if() is stable, so the relative order of elements that are
    *  copied is unchanged.
   */
-  template<typename _InputIter, typename _OutputIter, typename _Predicate>
-    _OutputIter
-    remove_copy_if(_InputIter __first, _InputIter __last,
-		   _OutputIter __result, _Predicate __pred)
+  template<typename _InputIterator, typename _OutputIterator, typename _Predicate>
+    _OutputIterator
+    remove_copy_if(_InputIterator __first, _InputIterator __last,
+		   _OutputIterator __result, _Predicate __pred)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-	    typename iterator_traits<_InputIter>::value_type>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator>::value_type>)
       __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
-	    typename iterator_traits<_InputIter>::value_type>)
+	    typename iterator_traits<_InputIterator>::value_type>)
 
       for ( ; __first != __last; ++__first)
 	if (!__pred(*__first)) {
@@ -1036,20 +1036,20 @@ namespace std
    *  Elements between the end of the resulting sequence and @p last
    *  are still present, but their value is unspecified.
   */
-  template<typename _ForwardIter, typename _Tp>
-    _ForwardIter
-    remove(_ForwardIter __first, _ForwardIter __last,
+  template<typename _ForwardIterator, typename _Tp>
+    _ForwardIterator
+    remove(_ForwardIterator __first, _ForwardIterator __last,
 	   const _Tp& __value)
     {
       // concept requirements
-      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_ConvertibleConcept<_Tp,
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_ForwardIterator>::value_type>)
       __glibcpp_function_requires(_EqualOpConcept<
-	    typename iterator_traits<_ForwardIter>::value_type, _Tp>)
+	    typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
 
       __first = find(__first, __last, __value);
-      _ForwardIter __i = __first;
+      _ForwardIterator __i = __first;
       return __first == __last ? __first
 			       : remove_copy(++__i, __last, __first, __value);
     }
@@ -1070,36 +1070,36 @@ namespace std
    *  Elements between the end of the resulting sequence and @p last
    *  are still present, but their value is unspecified.
   */
-  template<typename _ForwardIter, typename _Predicate>
-    _ForwardIter
-    remove_if(_ForwardIter __first, _ForwardIter __last,
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    remove_if(_ForwardIterator __first, _ForwardIterator __last,
 	      _Predicate __pred)
     {
       // concept requirements
-      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_ForwardIterator>::value_type>)
 
       __first = find_if(__first, __last, __pred);
-      _ForwardIter __i = __first;
+      _ForwardIterator __i = __first;
       return __first == __last ? __first
 			       : remove_copy_if(++__i, __last, __first, __pred);
     }
 
   /**
    *  @if maint
-   *  This is an uglified unique_copy(_InputIter, _InputIter, _OutputIter)
+   *  This is an uglified unique_copy(_InputIterator, _InputIterator, _OutputIterator)
    *  overloaded for output iterators.
    *  @endif
   */
-  template<typename _InputIter, typename _OutputIter>
-    _OutputIter
-    __unique_copy(_InputIter __first, _InputIter __last,
-		  _OutputIter __result,
+  template<typename _InputIterator, typename _OutputIterator>
+    _OutputIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+		  _OutputIterator __result,
 		  output_iterator_tag)
     {
       // concept requirements -- taken care of in dispatching function
-      typename iterator_traits<_InputIter>::value_type __value = *__first;
+      typename iterator_traits<_InputIterator>::value_type __value = *__first;
       *__result = __value;
       while (++__first != __last)
 	if (!(__value == *__first)) {
@@ -1111,14 +1111,14 @@ namespace std
 
   /**
    *  @if maint
-   *  This is an uglified unique_copy(_InputIter, _InputIter, _OutputIter)
+   *  This is an uglified unique_copy(_InputIterator, _InputIterator, _OutputIterator)
    *  overloaded for forward iterators.
    *  @endif
   */
-  template<typename _InputIter, typename _ForwardIter>
-    _ForwardIter
-    __unique_copy(_InputIter __first, _InputIter __last,
-		  _ForwardIter __result,
+  template<typename _InputIterator, typename _ForwardIterator>
+    _ForwardIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+		  _ForwardIterator __result,
 		  forward_iterator_tag)
     {
       // concept requirements -- taken care of in dispatching function
@@ -1142,19 +1142,19 @@ namespace std
    *  unique_copy() is stable, so the relative order of elements that are
    *  copied is unchanged.
   */
-  template<typename _InputIter, typename _OutputIter>
-    inline _OutputIter
-    unique_copy(_InputIter __first, _InputIter __last,
-		_OutputIter __result)
+  template<typename _InputIterator, typename _OutputIterator>
+    inline _OutputIterator
+    unique_copy(_InputIterator __first, _InputIterator __last,
+		_OutputIterator __result)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-	    typename iterator_traits<_InputIter>::value_type>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator>::value_type>)
       __glibcpp_function_requires(_EqualityComparableConcept<
-	    typename iterator_traits<_InputIter>::value_type>)
+	    typename iterator_traits<_InputIterator>::value_type>)
 
-      typedef typename iterator_traits<_OutputIter>::iterator_category _IterType;
+      typedef typename iterator_traits<_OutputIterator>::iterator_category _IterType;
 
       if (__first == __last) return __result;
       return __unique_copy(__first, __last, __result, _IterType());
@@ -1163,23 +1163,23 @@ namespace std
   /**
    *  @if maint
    *  This is an uglified
-   *  unique_copy(_InputIter, _InputIter, _OutputIter, _BinaryPredicate)
+   *  unique_copy(_InputIterator, _InputIterator, _OutputIterator, _BinaryPredicate)
    *  overloaded for output iterators.
    *  @endif
   */
-  template<typename _InputIter, typename _OutputIter, typename _BinaryPredicate>
-    _OutputIter
-    __unique_copy(_InputIter __first, _InputIter __last,
-		  _OutputIter __result,
+  template<typename _InputIterator, typename _OutputIterator, typename _BinaryPredicate>
+    _OutputIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+		  _OutputIterator __result,
 		  _BinaryPredicate __binary_pred,
 		  output_iterator_tag)
     {
       // concept requirements -- iterators already checked
       __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
-	  typename iterator_traits<_InputIter>::value_type,
-	  typename iterator_traits<_InputIter>::value_type>)
+	  typename iterator_traits<_InputIterator>::value_type,
+	  typename iterator_traits<_InputIterator>::value_type>)
 
-      typename iterator_traits<_InputIter>::value_type __value = *__first;
+      typename iterator_traits<_InputIterator>::value_type __value = *__first;
       *__result = __value;
       while (++__first != __last)
 	if (!__binary_pred(__value, *__first)) {
@@ -1192,21 +1192,21 @@ namespace std
   /**
    *  @if maint
    *  This is an uglified
-   *  unique_copy(_InputIter, _InputIter, _OutputIter, _BinaryPredicate)
+   *  unique_copy(_InputIterator, _InputIterator, _OutputIterator, _BinaryPredicate)
    *  overloaded for forward iterators.
    *  @endif
   */
-  template<typename _InputIter, typename _ForwardIter, typename _BinaryPredicate>
-    _ForwardIter
-    __unique_copy(_InputIter __first, _InputIter __last,
-		  _ForwardIter __result,
+  template<typename _InputIterator, typename _ForwardIterator, typename _BinaryPredicate>
+    _ForwardIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+		  _ForwardIterator __result,
 		  _BinaryPredicate __binary_pred,
 		  forward_iterator_tag)
     {
       // concept requirements -- iterators already checked
       __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
-	    typename iterator_traits<_ForwardIter>::value_type,
-	    typename iterator_traits<_InputIter>::value_type>)
+	    typename iterator_traits<_ForwardIterator>::value_type,
+	    typename iterator_traits<_InputIterator>::value_type>)
 
       *__result = *__first;
       while (++__first != __last)
@@ -1229,18 +1229,18 @@ namespace std
    *  unique_copy() is stable, so the relative order of elements that are
    *  copied is unchanged.
   */
-  template<typename _InputIter, typename _OutputIter, typename _BinaryPredicate>
-    inline _OutputIter
-    unique_copy(_InputIter __first, _InputIter __last,
-		_OutputIter __result,
+  template<typename _InputIterator, typename _OutputIterator, typename _BinaryPredicate>
+    inline _OutputIterator
+    unique_copy(_InputIterator __first, _InputIterator __last,
+		_OutputIterator __result,
 		_BinaryPredicate __binary_pred)
     {
       // concept requirements -- predicates checked later
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-	    typename iterator_traits<_InputIter>::value_type>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator>::value_type>)
 
-      typedef typename iterator_traits<_OutputIter>::iterator_category _IterType;
+      typedef typename iterator_traits<_OutputIterator>::iterator_category _IterType;
 
       if (__first == __last) return __result;
       return __unique_copy(__first, __last,
@@ -1260,14 +1260,14 @@ __result, __binary_pred, _IterType());
    *  Elements between the end of the resulting sequence and @p last
    *  are still present, but their value is unspecified.
   */
-  template<typename _ForwardIter>
-    _ForwardIter
-    unique(_ForwardIter __first, _ForwardIter __last)
+  template<typename _ForwardIterator>
+    _ForwardIterator
+    unique(_ForwardIterator __first, _ForwardIterator __last)
     {
 	  // concept requirements
-	  __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+	  __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
 	  __glibcpp_function_requires(_EqualityComparableConcept<
-		    typename iterator_traits<_ForwardIter>::value_type>)
+		    typename iterator_traits<_ForwardIterator>::value_type>)
 
 	  __first = adjacent_find(__first, __last);
 	  return unique_copy(__first, __last, __first);
@@ -1287,16 +1287,16 @@ __result, __binary_pred, _IterType());
    *  Elements between the end of the resulting sequence and @p last
    *  are still present, but their value is unspecified.
   */
-  template<typename _ForwardIter, typename _BinaryPredicate>
-    _ForwardIter
-    unique(_ForwardIter __first, _ForwardIter __last,
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    _ForwardIterator
+    unique(_ForwardIterator __first, _ForwardIterator __last,
            _BinaryPredicate __binary_pred)
     {
       // concept requirements
-      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
-		typename iterator_traits<_ForwardIter>::value_type,
-		typename iterator_traits<_ForwardIter>::value_type>)
+		typename iterator_traits<_ForwardIterator>::value_type,
+		typename iterator_traits<_ForwardIterator>::value_type>)
 
       __first = adjacent_find(__first, __last, __binary_pred);
       return unique_copy(__first, __last, __first, __binary_pred);
@@ -1304,13 +1304,13 @@ __result, __binary_pred, _IterType());
 
   /**
    *  @if maint
-   *  This is an uglified reverse(_BidirectionalIter, _BidirectionalIter)
+   *  This is an uglified reverse(_BidirectionalIterator, _BidirectionalIterator)
    *  overloaded for bidirectional iterators.
    *  @endif
   */
-  template<typename _BidirectionalIter>
+  template<typename _BidirectionalIterator>
     void
-    __reverse(_BidirectionalIter __first, _BidirectionalIter __last,
+    __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
 			  bidirectional_iterator_tag)
     {
 	  while (true)
@@ -1322,13 +1322,13 @@ __result, __binary_pred, _IterType());
 
   /**
    *  @if maint
-   *  This is an uglified reverse(_BidirectionalIter, _BidirectionalIter)
+   *  This is an uglified reverse(_BidirectionalIterator, _BidirectionalIterator)
    *  overloaded for bidirectional iterators.
    *  @endif
   */
-  template<typename _RandomAccessIter>
+  template<typename _RandomAccessIterator>
     void
-    __reverse(_RandomAccessIter __first, _RandomAccessIter __last,
+    __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
 			  random_access_iterator_tag)
     {
 	  while (__first < __last)
@@ -1346,13 +1346,13 @@ __result, __binary_pred, _IterType());
    *  For every @c i such that @p 0<=i<=(last-first)/2), @p reverse()
    *  swaps @p *(first+i) and @p *(last-(i+1))
   */
-  template<typename _BidirectionalIter>
+  template<typename _BidirectionalIterator>
     inline void
-    reverse(_BidirectionalIter __first, _BidirectionalIter __last)
+    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
     {
 	  // concept requirements
 	  __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<
-		    _BidirectionalIter>)
+		    _BidirectionalIterator>)
 	  __reverse(__first, __last, __iterator_category(__first));
     }
 
@@ -1371,15 +1371,15 @@ __result, __binary_pred, _IterType());
    *  The ranges @p [first,last) and @p [result,result+(last-first))
    *  must not overlap.
   */
-  template<typename _BidirectionalIter, typename _OutputIter>
-    _OutputIter
-    reverse_copy(_BidirectionalIter __first, _BidirectionalIter __last,
-			     _OutputIter __result)
+  template<typename _BidirectionalIterator, typename _OutputIterator>
+    _OutputIterator
+    reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
+			     _OutputIterator __result)
     {
       // concept requirements
-      __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-		typename iterator_traits<_BidirectionalIter>::value_type>)
+      __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+		typename iterator_traits<_BidirectionalIterator>::value_type>)
 
       while (__first != __last) {
 	--__last;
@@ -1413,17 +1413,17 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the rotate algorithm.
    *  @endif
   */
-  template<typename _ForwardIter>
+  template<typename _ForwardIterator>
     void
-    __rotate(_ForwardIter __first,
-	     _ForwardIter __middle,
-	     _ForwardIter __last,
+    __rotate(_ForwardIterator __first,
+	     _ForwardIterator __middle,
+	     _ForwardIterator __last,
 	      forward_iterator_tag)
     {
       if ((__first == __middle) || (__last  == __middle))
 	return;
 
-      _ForwardIter __first2 = __middle;
+      _ForwardIterator __first2 = __middle;
       do {
 	swap(*__first++, *__first2++);
 	if (__first == __middle)
@@ -1446,16 +1446,16 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the rotate algorithm.
    *  @endif
   */
-  template<typename _BidirectionalIter>
+  template<typename _BidirectionalIterator>
     void
-    __rotate(_BidirectionalIter __first,
-	     _BidirectionalIter __middle,
-	     _BidirectionalIter __last,
+    __rotate(_BidirectionalIterator __first,
+	     _BidirectionalIterator __middle,
+	     _BidirectionalIterator __last,
 	      bidirectional_iterator_tag)
     {
       // concept requirements
       __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<
-	    _BidirectionalIter>)
+	    _BidirectionalIterator>)
 
       if ((__first == __middle) || (__last  == __middle))
 	return;
@@ -1479,22 +1479,22 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the rotate algorithm.
    *  @endif
   */
-  template<typename _RandomAccessIter>
+  template<typename _RandomAccessIterator>
     void
-    __rotate(_RandomAccessIter __first,
-	     _RandomAccessIter __middle,
-	     _RandomAccessIter __last,
+    __rotate(_RandomAccessIterator __first,
+	     _RandomAccessIterator __middle,
+	     _RandomAccessIterator __last,
 	     random_access_iterator_tag)
     {
       // concept requirements
       __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
-	    _RandomAccessIter>)
+	    _RandomAccessIterator>)
 
       if ((__first == __middle) || (__last  == __middle))
 	return;
 
-      typedef typename iterator_traits<_RandomAccessIter>::difference_type _Distance;
-      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
 
       _Distance __n = __last   - __first;
       _Distance __k = __middle - __first;
@@ -1509,7 +1509,7 @@ __result, __binary_pred, _IterType());
 
       for (_Distance __i = 0; __i < __d; __i++) {
 	_ValueType __tmp = *__first;
-	_RandomAccessIter __p = __first;
+	_RandomAccessIterator __p = __first;
 
 	if (__k < __l) {
 	  for (_Distance __j = 0; __j < __l/__d; __j++) {
@@ -1558,14 +1558,14 @@ __result, __binary_pred, _IterType());
    *  Performs @p *(first+(n+(last-middle))%(last-first))=*(first+n) for
    *  each @p n in the range @p [0,last-first).
   */
-  template<typename _ForwardIter>
+  template<typename _ForwardIterator>
     inline void
-    rotate(_ForwardIter __first, _ForwardIter __middle, _ForwardIter __last)
+    rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
     {
       // concept requirements
-      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
 
-      typedef typename iterator_traits<_ForwardIter>::iterator_category _IterType;
+      typedef typename iterator_traits<_ForwardIterator>::iterator_category _IterType;
       __rotate(__first, __middle, __last, _IterType());
     }
 
@@ -1586,15 +1586,15 @@ __result, __binary_pred, _IterType());
    *  Performs @p *(result+(n+(last-middle))%(last-first))=*(first+n) for
    *  each @p n in the range @p [0,last-first).
   */
-  template<typename _ForwardIter, typename _OutputIter>
-    _OutputIter
-    rotate_copy(_ForwardIter __first, _ForwardIter __middle,
-                _ForwardIter __last, _OutputIter __result)
+  template<typename _ForwardIterator, typename _OutputIterator>
+    _OutputIterator
+    rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
+                _ForwardIterator __last, _OutputIterator __result)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-		typename iterator_traits<_ForwardIter>::value_type>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+		typename iterator_traits<_ForwardIterator>::value_type>)
 
       return copy(__first, __middle, copy(__middle, __last, __result));
     }
@@ -1631,16 +1631,16 @@ __result, __binary_pred, _IterType());
    *  distribution, so that every possible ordering of the sequence is
    *  equally likely.
   */
-  template<typename _RandomAccessIter>
+  template<typename _RandomAccessIterator>
     inline void
-    random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last)
+    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
     {
       // concept requirements
       __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
-	    _RandomAccessIter>)
+	    _RandomAccessIterator>)
 
       if (__first == __last) return;
-      for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 	iter_swap(__i, __first + __random_number((__i - __first) + 1));
     }
 
@@ -1657,17 +1657,17 @@ __result, __binary_pred, _IterType());
    *  integer @p N should return a randomly chosen integer from the
    *  range [0,N).
   */
-  template<typename _RandomAccessIter, typename _RandomNumberGenerator>
+  template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
     void
-    random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last,
+    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
 		   _RandomNumberGenerator& __rand)
     {
       // concept requirements
       __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
-	    _RandomAccessIter>)
+	    _RandomAccessIterator>)
 
       if (__first == __last) return;
-      for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 	iter_swap(__i, __first + __rand((__i - __first) + 1));
     }
 
@@ -1677,9 +1677,9 @@ __result, __binary_pred, _IterType());
    *  This is a helper function...
    *  @endif
   */
-  template<typename _ForwardIter, typename _Predicate>
-    _ForwardIter
-    __partition(_ForwardIter __first, _ForwardIter __last,
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    __partition(_ForwardIterator __first, _ForwardIterator __last,
 		_Predicate   __pred,
 		forward_iterator_tag)
     {
@@ -1688,7 +1688,7 @@ __result, __binary_pred, _IterType());
       while (__pred(*__first))
 	if (++__first == __last) return __first;
 
-      _ForwardIter __next = __first;
+      _ForwardIterator __next = __first;
 
       while (++__next != __last)
 	if (__pred(*__next)) {
@@ -1704,9 +1704,9 @@ __result, __binary_pred, _IterType());
    *  This is a helper function...
    *  @endif
   */
-  template<typename _BidirectionalIter, typename _Predicate>
-    _BidirectionalIter
-    __partition(_BidirectionalIter __first, _BidirectionalIter __last,
+  template<typename _BidirectionalIterator, typename _Predicate>
+    _BidirectionalIterator
+    __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
 		_Predicate __pred,
 		bidirectional_iterator_tag)
     {
@@ -1745,15 +1745,15 @@ __result, __binary_pred, _IterType());
    *  the relative ordering of elements in each group, use
    *  @p stable_partition() if this is needed.
   */
-  template<typename _ForwardIter, typename _Predicate>
-    inline _ForwardIter
-    partition(_ForwardIter __first, _ForwardIter __last,
+  template<typename _ForwardIterator, typename _Predicate>
+    inline _ForwardIterator
+    partition(_ForwardIterator __first, _ForwardIterator __last,
 	      _Predicate   __pred)
     {
       // concept requirements
-      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_ForwardIterator>::value_type>)
 
       return __partition(__first, __last, __pred, __iterator_category(__first));
     }
@@ -1764,19 +1764,19 @@ __result, __binary_pred, _IterType());
    *  This is a helper function...
    *  @endif
   */
-  template<typename _ForwardIter, typename _Predicate, typename _Distance>
-    _ForwardIter
-    __inplace_stable_partition(_ForwardIter __first, _ForwardIter __last,
+  template<typename _ForwardIterator, typename _Predicate, typename _Distance>
+    _ForwardIterator
+    __inplace_stable_partition(_ForwardIterator __first, _ForwardIterator __last,
 			       _Predicate __pred, _Distance __len)
     {
       if (__len == 1)
 	return __pred(*__first) ? __last : __first;
-      _ForwardIter __middle = __first;
+      _ForwardIterator __middle = __first;
       advance(__middle, __len / 2);
-      _ForwardIter __begin = __inplace_stable_partition(__first, __middle,
+      _ForwardIterator __begin = __inplace_stable_partition(__first, __middle,
 							__pred,
 							__len / 2);
-      _ForwardIter __end = __inplace_stable_partition(__middle, __last,
+      _ForwardIterator __end = __inplace_stable_partition(__middle, __last,
 						      __pred,
 						      __len - __len / 2);
       rotate(__begin, __middle, __end);
@@ -1789,16 +1789,16 @@ __result, __binary_pred, _IterType());
    *  This is a helper function...
    *  @endif
   */
-  template<typename _ForwardIter, typename _Pointer, typename _Predicate,
+  template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
 	   typename _Distance>
-    _ForwardIter
-    __stable_partition_adaptive(_ForwardIter __first, _ForwardIter __last,
+    _ForwardIterator
+    __stable_partition_adaptive(_ForwardIterator __first, _ForwardIterator __last,
 				_Predicate __pred, _Distance __len,
 				_Pointer __buffer,
 				_Distance __buffer_size)
     {
       if (__len <= __buffer_size) {
-	_ForwardIter __result1 = __first;
+	_ForwardIterator __result1 = __first;
 	_Pointer __result2 = __buffer;
 	for ( ; __first != __last ; ++__first)
 	  if (__pred(*__first)) {
@@ -1813,13 +1813,13 @@ __result, __binary_pred, _IterType());
 	return __result1;
       }
       else {
-	_ForwardIter __middle = __first;
+	_ForwardIterator __middle = __first;
 	advance(__middle, __len / 2);
-	_ForwardIter __begin = __stable_partition_adaptive(__first, __middle,
+	_ForwardIterator __begin = __stable_partition_adaptive(__first, __middle,
 							   __pred,
 							   __len / 2,
 							   __buffer, __buffer_size);
-	_ForwardIter __end = __stable_partition_adaptive( __middle, __last,
+	_ForwardIterator __end = __stable_partition_adaptive( __middle, __last,
 							  __pred,
 							  __len - __len / 2,
 							  __buffer, __buffer_size);
@@ -1845,24 +1845,24 @@ __result, __binary_pred, _IterType());
    *  @p [first,last) such that @p pred(x)==pred(y) will have the same
    *  relative ordering after calling @p stable_partition().
   */
-  template<typename _ForwardIter, typename _Predicate>
-    _ForwardIter
-    stable_partition(_ForwardIter __first, _ForwardIter __last,
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    stable_partition(_ForwardIterator __first, _ForwardIterator __last,
 		     _Predicate __pred)
     {
       // concept requirements
-      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_ForwardIterator>::value_type>)
 
       if (__first == __last)
 	return __first;
       else
       {
-	typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
-	typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;
+	typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+	typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
 
-	_Temporary_buffer<_ForwardIter, _ValueType> __buf(__first, __last);
+	_Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first, __last);
 	if (__buf.size() > 0)
 	  return __stable_partition_adaptive(__first, __last, __pred,
 					     _DistanceType(__buf.requested_size()),
@@ -1878,9 +1878,9 @@ __result, __binary_pred, _IterType());
    *  This is a helper function...
    *  @endif
   */
-  template<typename _RandomAccessIter, typename _Tp>
-    _RandomAccessIter
-    __unguarded_partition(_RandomAccessIter __first, _RandomAccessIter __last,
+  template<typename _RandomAccessIterator, typename _Tp>
+    _RandomAccessIterator
+    __unguarded_partition(_RandomAccessIterator __first, _RandomAccessIterator __last,
 			  _Tp __pivot)
     {
       while (true) {
@@ -1901,9 +1901,9 @@ __result, __binary_pred, _IterType());
    *  This is a helper function...
    *  @endif
   */
-  template<typename _RandomAccessIter, typename _Tp, typename _Compare>
-    _RandomAccessIter
-    __unguarded_partition(_RandomAccessIter __first, _RandomAccessIter __last,
+  template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
+    _RandomAccessIterator
+    __unguarded_partition(_RandomAccessIterator __first, _RandomAccessIterator __last,
 			  _Tp __pivot, _Compare __comp)
     {
       while (true) {
@@ -1933,11 +1933,11 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the sort routine.
    *  @endif
   */
-  template<typename _RandomAccessIter, typename _Tp>
+  template<typename _RandomAccessIterator, typename _Tp>
     void
-    __unguarded_linear_insert(_RandomAccessIter __last, _Tp __val)
+    __unguarded_linear_insert(_RandomAccessIterator __last, _Tp __val)
     {
-      _RandomAccessIter __next = __last;
+      _RandomAccessIterator __next = __last;
       --__next;
       while (__val < *__next) {
 	*__last = *__next;
@@ -1952,11 +1952,11 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the sort routine.
    *  @endif
   */
-  template<typename _RandomAccessIter, typename _Tp, typename _Compare>
+  template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
     void
-    __unguarded_linear_insert(_RandomAccessIter __last, _Tp __val, _Compare __comp)
+    __unguarded_linear_insert(_RandomAccessIterator __last, _Tp __val, _Compare __comp)
     {
-      _RandomAccessIter __next = __last;
+      _RandomAccessIterator __next = __last;
       --__next;
       while (__comp(__val, *__next)) {
 	*__last = *__next;
@@ -1971,15 +1971,15 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the sort routine.
    *  @endif
   */
-  template<typename _RandomAccessIter>
+  template<typename _RandomAccessIterator>
     void
-    __insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last)
+    __insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
     {
       if (__first == __last) return;
 
-      for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
       {
-	typename iterator_traits<_RandomAccessIter>::value_type __val = *__i;
+	typename iterator_traits<_RandomAccessIterator>::value_type __val = *__i;
 	if (__val < *__first) {
 	  copy_backward(__first, __i, __i + 1);
 	  *__first = __val;
@@ -1994,16 +1994,16 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the sort routine.
    *  @endif
   */
-  template<typename _RandomAccessIter, typename _Compare>
+  template<typename _RandomAccessIterator, typename _Compare>
     void
-    __insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last,
+    __insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
 		     _Compare __comp)
     {
       if (__first == __last) return;
 
-      for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
       {
-	typename iterator_traits<_RandomAccessIter>::value_type __val = *__i;
+	typename iterator_traits<_RandomAccessIterator>::value_type __val = *__i;
 	if (__comp(__val, *__first)) {
 	  copy_backward(__first, __i, __i + 1);
 	  *__first = __val;
@@ -2018,13 +2018,13 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the sort routine.
    *  @endif
   */
-  template<typename _RandomAccessIter>
+  template<typename _RandomAccessIterator>
     inline void
-    __unguarded_insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last)
+    __unguarded_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
     {
-      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
 
-      for (_RandomAccessIter __i = __first; __i != __last; ++__i)
+      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
 	__unguarded_linear_insert(__i, _ValueType(*__i));
     }
 
@@ -2033,14 +2033,14 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the sort routine.
    *  @endif
   */
-  template<typename _RandomAccessIter, typename _Compare>
+  template<typename _RandomAccessIterator, typename _Compare>
     inline void
-    __unguarded_insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last,
+    __unguarded_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
 			       _Compare __comp)
     {
-      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
 
-      for (_RandomAccessIter __i = __first; __i != __last; ++__i)
+      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
 	__unguarded_linear_insert(__i, _ValueType(*__i), __comp);
     }
 
@@ -2049,9 +2049,9 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the sort routine.
    *  @endif
   */
-  template<typename _RandomAccessIter>
+  template<typename _RandomAccessIterator>
     void
-    __final_insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last)
+    __final_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
     {
       if (__last - __first > _S_threshold) {
 	__insertion_sort(__first, __first + _S_threshold);
@@ -2066,9 +2066,9 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the sort routine.
    *  @endif
   */
-  template<typename _RandomAccessIter, typename _Compare>
+  template<typename _RandomAccessIterator, typename _Compare>
     void
-    __final_insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last,
+    __final_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
 			   _Compare __comp)
     {
       if (__last - __first > _S_threshold) {
@@ -2098,12 +2098,12 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the sort routine.
    *  @endif
   */
-  template<typename _RandomAccessIter, typename _Size>
+  template<typename _RandomAccessIterator, typename _Size>
     void
-    __introsort_loop(_RandomAccessIter __first, _RandomAccessIter __last,
+    __introsort_loop(_RandomAccessIterator __first, _RandomAccessIterator __last,
 		     _Size __depth_limit)
     {
-      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
 
       while (__last - __first > _S_threshold) {
 	if (__depth_limit == 0) {
@@ -2111,7 +2111,7 @@ __result, __binary_pred, _IterType());
 	  return;
 	}
 	--__depth_limit;
-	_RandomAccessIter __cut =
+	_RandomAccessIterator __cut =
 	  __unguarded_partition(__first, __last,
 				_ValueType(__median(*__first,
 						    *(__first + (__last - __first)/2),
@@ -2126,12 +2126,12 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the sort routine.
    *  @endif
   */
-  template<typename _RandomAccessIter, typename _Size, typename _Compare>
+  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
     void
-    __introsort_loop(_RandomAccessIter __first, _RandomAccessIter __last,
+    __introsort_loop(_RandomAccessIterator __first, _RandomAccessIterator __last,
 		     _Size __depth_limit, _Compare __comp)
     {
-      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
 
       while (__last - __first > _S_threshold) {
 	if (__depth_limit == 0) {
@@ -2139,7 +2139,7 @@ __result, __binary_pred, _IterType());
 	  return;
 	}
 	--__depth_limit;
-	_RandomAccessIter __cut =
+	_RandomAccessIterator __cut =
 	  __unguarded_partition(__first, __last,
 				_ValueType(__median(*__first,
 						    *(__first + (__last - __first)/2),
@@ -2163,15 +2163,15 @@ __result, __binary_pred, _IterType());
    *  The relative ordering of equivalent elements is not preserved, use
    *  @p stable_sort() if this is needed.
   */
-  template<typename _RandomAccessIter>
+  template<typename _RandomAccessIterator>
     inline void
-    sort(_RandomAccessIter __first, _RandomAccessIter __last)
+    sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
     {
-      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
 
       // concept requirements
       __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
-	    _RandomAccessIter>)
+	    _RandomAccessIterator>)
       __glibcpp_function_requires(_LessThanComparableConcept<_ValueType>)
 
       if (__first != __last) {
@@ -2194,15 +2194,15 @@ __result, __binary_pred, _IterType());
    *  The relative ordering of equivalent elements is not preserved, use
    *  @p stable_sort() if this is needed.
   */
-  template<typename _RandomAccessIter, typename _Compare>
+  template<typename _RandomAccessIterator, typename _Compare>
     inline void
-    sort(_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp)
+    sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
     {
-      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
 
       // concept requirements
       __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
-	    _RandomAccessIter>)
+	    _RandomAccessIterator>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _ValueType, _ValueType>)
 
       if (__first != __last) {
@@ -2217,15 +2217,15 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the stable sorting routines.
    *  @endif
   */
-  template<typename _RandomAccessIter>
+  template<typename _RandomAccessIterator>
     void
-    __inplace_stable_sort(_RandomAccessIter __first, _RandomAccessIter __last)
+    __inplace_stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
     {
       if (__last - __first < 15) {
 	__insertion_sort(__first, __last);
 	return;
       }
-      _RandomAccessIter __middle = __first + (__last - __first) / 2;
+      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
       __inplace_stable_sort(__first, __middle);
       __inplace_stable_sort(__middle, __last);
       __merge_without_buffer(__first, __middle, __last,
@@ -2238,16 +2238,16 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the stable sorting routines.
    *  @endif
   */
-  template<typename _RandomAccessIter, typename _Compare>
+  template<typename _RandomAccessIterator, typename _Compare>
     void
-    __inplace_stable_sort(_RandomAccessIter __first, _RandomAccessIter __last,
+    __inplace_stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
 			  _Compare __comp)
     {
       if (__last - __first < 15) {
 	__insertion_sort(__first, __last, __comp);
 	return;
       }
-      _RandomAccessIter __middle = __first + (__last - __first) / 2;
+      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
       __inplace_stable_sort(__first, __middle, __comp);
       __inplace_stable_sort(__middle, __last, __comp);
       __merge_without_buffer(__first, __middle, __last,
@@ -2256,11 +2256,11 @@ __result, __binary_pred, _IterType());
 			     __comp);
     }
 
-  template<typename _RandomAccessIter1, typename _RandomAccessIter2,
+  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
 	   typename _Distance>
     void
-    __merge_sort_loop(_RandomAccessIter1 __first, _RandomAccessIter1 __last,
-		      _RandomAccessIter2 __result, _Distance __step_size)
+    __merge_sort_loop(_RandomAccessIterator1 __first, _RandomAccessIterator1 __last,
+		      _RandomAccessIterator2 __result, _Distance __step_size)
     {
       _Distance __two_step = 2 * __step_size;
 
@@ -2276,11 +2276,11 @@ __result, __binary_pred, _IterType());
 	    __result);
     }
 
-  template<typename _RandomAccessIter1, typename _RandomAccessIter2,
+  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
 	   typename _Distance, typename _Compare>
     void
-    __merge_sort_loop(_RandomAccessIter1 __first, _RandomAccessIter1 __last,
-		      _RandomAccessIter2 __result, _Distance __step_size,
+    __merge_sort_loop(_RandomAccessIterator1 __first, _RandomAccessIterator1 __last,
+		      _RandomAccessIterator2 __result, _Distance __step_size,
 		      _Compare __comp)
     {
       _Distance __two_step = 2 * __step_size;
@@ -2302,9 +2302,9 @@ __result, __binary_pred, _IterType());
 
   enum { _S_chunk_size = 7 };
 
-  template<typename _RandomAccessIter, typename _Distance>
+  template<typename _RandomAccessIterator, typename _Distance>
     void
-    __chunk_insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last,
+    __chunk_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
 			   _Distance __chunk_size)
     {
       while (__last - __first >= __chunk_size) {
@@ -2314,9 +2314,9 @@ __result, __binary_pred, _IterType());
       __insertion_sort(__first, __last);
     }
 
-  template<typename _RandomAccessIter, typename _Distance, typename _Compare>
+  template<typename _RandomAccessIterator, typename _Distance, typename _Compare>
     void
-    __chunk_insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last,
+    __chunk_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
 			   _Distance __chunk_size, _Compare __comp)
     {
       while (__last - __first >= __chunk_size) {
@@ -2326,12 +2326,12 @@ __result, __binary_pred, _IterType());
       __insertion_sort(__first, __last, __comp);
     }
 
-  template<typename _RandomAccessIter, typename _Pointer>
+  template<typename _RandomAccessIterator, typename _Pointer>
     void
-    __merge_sort_with_buffer(_RandomAccessIter __first, _RandomAccessIter __last,
+    __merge_sort_with_buffer(_RandomAccessIterator __first, _RandomAccessIterator __last,
                              _Pointer __buffer)
     {
-      typedef typename iterator_traits<_RandomAccessIter>::difference_type _Distance;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance;
 
       _Distance __len = __last - __first;
       _Pointer __buffer_last = __buffer + __len;
@@ -2347,12 +2347,12 @@ __result, __binary_pred, _IterType());
       }
     }
 
-  template<typename _RandomAccessIter, typename _Pointer, typename _Compare>
+  template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
     void
-    __merge_sort_with_buffer(_RandomAccessIter __first, _RandomAccessIter __last,
+    __merge_sort_with_buffer(_RandomAccessIterator __first, _RandomAccessIterator __last,
                              _Pointer __buffer, _Compare __comp)
     {
-      typedef typename iterator_traits<_RandomAccessIter>::difference_type _Distance;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance;
 
       _Distance __len = __last - __first;
       _Pointer __buffer_last = __buffer + __len;
@@ -2368,13 +2368,13 @@ __result, __binary_pred, _IterType());
       }
     }
 
-  template<typename _RandomAccessIter, typename _Pointer, typename _Distance>
+  template<typename _RandomAccessIterator, typename _Pointer, typename _Distance>
     void
-    __stable_sort_adaptive(_RandomAccessIter __first, _RandomAccessIter __last,
+    __stable_sort_adaptive(_RandomAccessIterator __first, _RandomAccessIterator __last,
                            _Pointer __buffer, _Distance __buffer_size)
     {
       _Distance __len = (__last - __first + 1) / 2;
-      _RandomAccessIter __middle = __first + __len;
+      _RandomAccessIterator __middle = __first + __len;
       if (__len > __buffer_size) {
 	__stable_sort_adaptive(__first, __middle, __buffer, __buffer_size);
 	__stable_sort_adaptive(__middle, __last, __buffer, __buffer_size);
@@ -2387,15 +2387,15 @@ __result, __binary_pred, _IterType());
                        _Distance(__last - __middle), __buffer, __buffer_size);
     }
 
-  template<typename _RandomAccessIter, typename _Pointer, typename _Distance,
+  template<typename _RandomAccessIterator, typename _Pointer, typename _Distance,
            typename _Compare>
     void
-    __stable_sort_adaptive(_RandomAccessIter __first, _RandomAccessIter __last,
+    __stable_sort_adaptive(_RandomAccessIterator __first, _RandomAccessIterator __last,
                            _Pointer __buffer, _Distance __buffer_size,
                            _Compare __comp)
     {
       _Distance __len = (__last - __first + 1) / 2;
-      _RandomAccessIter __middle = __first + __len;
+      _RandomAccessIterator __middle = __first + __len;
       if (__len > __buffer_size) {
 	__stable_sort_adaptive(__first, __middle, __buffer, __buffer_size,
                                __comp);
@@ -2427,19 +2427,19 @@ __result, __binary_pred, _IterType());
    *  @p x<y is false and @p y<x is false will have the same relative
    *  ordering after calling @p stable_sort().
   */
-  template<typename _RandomAccessIter>
+  template<typename _RandomAccessIterator>
     inline void
-    stable_sort(_RandomAccessIter __first, _RandomAccessIter __last)
+    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
     {
-      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
-      typedef typename iterator_traits<_RandomAccessIter>::difference_type _DistanceType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType;
 
       // concept requirements
       __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
-	    _RandomAccessIter>)
+	    _RandomAccessIterator>)
       __glibcpp_function_requires(_LessThanComparableConcept<_ValueType>)
 
-      _Temporary_buffer<_RandomAccessIter, _ValueType> buf(__first, __last);
+      _Temporary_buffer<_RandomAccessIterator, _ValueType> buf(__first, __last);
       if (buf.begin() == 0)
 	__inplace_stable_sort(__first, __last);
       else
@@ -2463,20 +2463,20 @@ __result, __binary_pred, _IterType());
    *  @p comp(x,y) is false and @p comp(y,x) is false will have the same
    *  relative ordering after calling @p stable_sort().
   */
-  template<typename _RandomAccessIter, typename _Compare>
+  template<typename _RandomAccessIterator, typename _Compare>
     inline void
-    stable_sort(_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp)
+    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
     {
-      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
-      typedef typename iterator_traits<_RandomAccessIter>::difference_type _DistanceType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType;
 
       // concept requirements
       __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
-	    _RandomAccessIter>)
+	    _RandomAccessIterator>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
 							  _ValueType, _ValueType>)
 
-      _Temporary_buffer<_RandomAccessIter, _ValueType> buf(__first, __last);
+      _Temporary_buffer<_RandomAccessIterator, _ValueType> buf(__first, __last);
       if (buf.begin() == 0)
 	__inplace_stable_sort(__first, __last, __comp);
       else
@@ -2499,21 +2499,21 @@ __result, __binary_pred, _IterType());
    *  @p [first,middle) such that @i precedes @j and @k is an iterator in
    *  the range @p [middle,last) then @p *j<*i and @p *k<*i are both false.
   */
-  template<typename _RandomAccessIter>
+  template<typename _RandomAccessIterator>
     void
-    partial_sort(_RandomAccessIter __first,
-		 _RandomAccessIter __middle,
-		 _RandomAccessIter __last)
+    partial_sort(_RandomAccessIterator __first,
+		 _RandomAccessIterator __middle,
+		 _RandomAccessIterator __last)
     {
-      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
 
       // concept requirements
       __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
-	    _RandomAccessIter>)
+	    _RandomAccessIterator>)
       __glibcpp_function_requires(_LessThanComparableConcept<_ValueType>)
 
       make_heap(__first, __middle);
-      for (_RandomAccessIter __i = __middle; __i < __last; ++__i)
+      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
 	if (*__i < *__first)
 	  __pop_heap(__first, __middle, __i, _ValueType(*__i));
       sort_heap(__first, __middle);
@@ -2537,23 +2537,23 @@ __result, __binary_pred, _IterType());
    *  the range @p [middle,last) then @p *comp(j,*i) and @p comp(*k,*i)
    *  are both false.
   */
-  template<typename _RandomAccessIter, typename _Compare>
+  template<typename _RandomAccessIterator, typename _Compare>
     void
-    partial_sort(_RandomAccessIter __first,
-		 _RandomAccessIter __middle,
-		 _RandomAccessIter __last,
+    partial_sort(_RandomAccessIterator __first,
+		 _RandomAccessIterator __middle,
+		 _RandomAccessIterator __last,
 		 _Compare __comp)
     {
-      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
 
       // concept requirements
       __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
-	    _RandomAccessIter>)
+	    _RandomAccessIterator>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
 							  _ValueType, _ValueType>)
 
       make_heap(__first, __middle, __comp);
-      for (_RandomAccessIter __i = __middle; __i < __last; ++__i)
+      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
 	if (__comp(*__i, *__first))
 	  __pop_heap(__first, __middle, __i, _ValueType(*__i), __comp);
       sort_heap(__first, __middle, __comp);
@@ -2576,24 +2576,24 @@ __result, __binary_pred, _IterType());
    *  @p *j<*i is false.
    *  The value returned is @p result_first+N.
   */
-  template<typename _InputIter, typename _RandomAccessIter>
-    _RandomAccessIter
-    partial_sort_copy(_InputIter __first, _InputIter __last,
-		      _RandomAccessIter __result_first,
-		      _RandomAccessIter __result_last)
+  template<typename _InputIterator, typename _RandomAccessIterator>
+    _RandomAccessIterator
+    partial_sort_copy(_InputIterator __first, _InputIterator __last,
+		      _RandomAccessIterator __result_first,
+		      _RandomAccessIterator __result_last)
     {
-      typedef typename iterator_traits<_InputIter>::value_type _InputValueType;
-      typedef typename iterator_traits<_RandomAccessIter>::value_type _OutputValueType;
-      typedef typename iterator_traits<_RandomAccessIter>::difference_type _DistanceType;
+      typedef typename iterator_traits<_InputIterator>::value_type _InputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type _OutputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType;
 
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
       __glibcpp_function_requires(_ConvertibleConcept<_InputValueType, _OutputValueType>)
       __glibcpp_function_requires(_LessThanComparableConcept<_OutputValueType>)
       __glibcpp_function_requires(_LessThanComparableConcept<_InputValueType>)
 
       if (__result_first == __result_last) return __result_last;
-      _RandomAccessIter __result_real_last = __result_first;
+      _RandomAccessIterator __result_real_last = __result_first;
       while(__first != __last && __result_real_last != __result_last) {
 	*__result_real_last = *__first;
 	++__result_real_last;
@@ -2630,26 +2630,26 @@ __result, __binary_pred, _IterType());
    *  @p comp(*j,*i) is false.
    *  The value returned is @p result_first+N.
   */
-  template<typename _InputIter, typename _RandomAccessIter, typename _Compare>
-    _RandomAccessIter
-    partial_sort_copy(_InputIter __first, _InputIter __last,
-		      _RandomAccessIter __result_first,
-		      _RandomAccessIter __result_last,
+  template<typename _InputIterator, typename _RandomAccessIterator, typename _Compare>
+    _RandomAccessIterator
+    partial_sort_copy(_InputIterator __first, _InputIterator __last,
+		      _RandomAccessIterator __result_first,
+		      _RandomAccessIterator __result_last,
 		      _Compare __comp)
     {
-      typedef typename iterator_traits<_InputIter>::value_type _InputValueType;
-      typedef typename iterator_traits<_RandomAccessIter>::value_type _OutputValueType;
-      typedef typename iterator_traits<_RandomAccessIter>::difference_type _DistanceType;
+      typedef typename iterator_traits<_InputIterator>::value_type _InputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type _OutputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType;
 
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
-      __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<_RandomAccessIter>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<_RandomAccessIterator>)
       __glibcpp_function_requires(_ConvertibleConcept<_InputValueType, _OutputValueType>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
 				  _OutputValueType, _OutputValueType>)
 
       if (__result_first == __result_last) return __result_last;
-      _RandomAccessIter __result_real_last = __result_first;
+      _RandomAccessIterator __result_real_last = __result_first;
       while(__first != __last && __result_real_last != __result_last) {
 	*__result_real_last = *__first;
 	++__result_real_last;
@@ -2683,20 +2683,20 @@ __result, __binary_pred, _IterType());
    *  @p [first,nth) and any iterator @j in the range @p [nth,last) it
    *  holds that @p *j<*i is false.
   */
-  template<typename _RandomAccessIter>
+  template<typename _RandomAccessIterator>
     void
-    nth_element(_RandomAccessIter __first,
-		_RandomAccessIter __nth,
-		_RandomAccessIter __last)
+    nth_element(_RandomAccessIterator __first,
+		_RandomAccessIterator __nth,
+		_RandomAccessIterator __last)
     {
-      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
 
       // concept requirements
-      __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<_RandomAccessIter>)
+      __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<_RandomAccessIterator>)
       __glibcpp_function_requires(_LessThanComparableConcept<_ValueType>)
 
       while (__last - __first > 3) {
-	_RandomAccessIter __cut =
+	_RandomAccessIterator __cut =
 	  __unguarded_partition(__first, __last,
 				_ValueType(__median(*__first,
 						    *(__first + (__last - __first)/2),
@@ -2725,22 +2725,22 @@ __result, __binary_pred, _IterType());
    *  @p [first,nth) and any iterator @j in the range @p [nth,last) it
    *  holds that @p comp(*j,*i) is false.
   */
-  template<typename _RandomAccessIter, typename _Compare>
+  template<typename _RandomAccessIterator, typename _Compare>
     void
-    nth_element(_RandomAccessIter __first,
-		_RandomAccessIter __nth,
-		_RandomAccessIter __last,
+    nth_element(_RandomAccessIterator __first,
+		_RandomAccessIterator __nth,
+		_RandomAccessIterator __last,
 			    _Compare __comp)
     {
-      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
 
       // concept requirements
-      __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<_RandomAccessIter>)
+      __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<_RandomAccessIterator>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
 				  _ValueType, _ValueType>)
 
       while (__last - __first > 3) {
-	_RandomAccessIter __cut =
+	_RandomAccessIterator __cut =
 	  __unguarded_partition(__first, __last,
 				_ValueType(__median(*__first,
 						    *(__first + (__last - __first)/2),
@@ -2762,28 +2762,29 @@ __result, __binary_pred, _IterType());
    *  @param  first   An iterator.
    *  @param  last    Another iterator.
    *  @param  val     The search term.
-   *  @return  An iterator pointing to the first element "not less than" @a val.
+   *  @return  An iterator pointing to the first element "not less than" @a val,
+   *           or end() if every element is less than @a val.
    *  @ingroup binarysearch
   */
-  template<typename _ForwardIter, typename _Tp>
-    _ForwardIter
-    lower_bound(_ForwardIter __first, _ForwardIter __last, const _Tp& __val)
+  template<typename _ForwardIterator, typename _Tp>
+    _ForwardIterator
+    lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val)
     {
-      typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
-      typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;
+      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
 
       // concept requirements
       // Note that these are slightly stricter than those of the 4-argument
       // version, defined next.  The difference is in the strictness of the
       // comparison operations... so for looser checking, define your own
       // comparison function, as was intended.
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_SameTypeConcept<_Tp, _ValueType>)
       __glibcpp_function_requires(_LessThanComparableConcept<_Tp>)
 
       _DistanceType __len = std::distance(__first, __last);
       _DistanceType __half;
-      _ForwardIter __middle;
+      _ForwardIterator __middle;
 
       while (__len > 0) {
 	__half = __len >> 1;
@@ -2807,27 +2808,28 @@ __result, __binary_pred, _IterType());
    *  @param  last    Another iterator.
    *  @param  val     The search term.
    *  @param  comp    A functor to use for comparisons.
-   *  @return  An iterator pointing to the first element "not less than" @a val.
+   *  @return  An iterator pointing to the first element "not less than" @a val,
+   *           or end() if every element is less than @a val.
    *  @ingroup binarysearch
    *
    *  The comparison function should have the same effects on ordering as
    *  the function used for the initial sort.
   */
-  template<typename _ForwardIter, typename _Tp, typename _Compare>
-    _ForwardIter
-    lower_bound(_ForwardIter __first, _ForwardIter __last,
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    _ForwardIterator
+    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
 		const _Tp& __val, _Compare __comp)
     {
-      typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
-      typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;
+      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
 
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _ValueType, _Tp>)
 
       _DistanceType __len = std::distance(__first, __last);
       _DistanceType __half;
-      _ForwardIter __middle;
+      _ForwardIterator __middle;
 
       while (__len > 0) {
 	__half = __len >> 1;
@@ -2850,25 +2852,26 @@ __result, __binary_pred, _IterType());
    *  @param  first   An iterator.
    *  @param  last    Another iterator.
    *  @param  val     The search term.
-   *  @return  An iterator pointing to the first element greater than @a val.
+   *  @return  An iterator pointing to the first element greater than @a val,
+   *           or end() if no elements are greater than @a val.
    *  @ingroup binarysearch
   */
-  template<typename _ForwardIter, typename _Tp>
-    _ForwardIter
-    upper_bound(_ForwardIter __first, _ForwardIter __last, const _Tp& __val)
+  template<typename _ForwardIterator, typename _Tp>
+    _ForwardIterator
+    upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val)
     {
-      typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
-      typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;
+      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
 
       // concept requirements
       // See comments on lower_bound.
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_SameTypeConcept<_Tp, _ValueType>)
       __glibcpp_function_requires(_LessThanComparableConcept<_Tp>)
 
       _DistanceType __len = std::distance(__first, __last);
       _DistanceType __half;
-      _ForwardIter __middle;
+      _ForwardIterator __middle;
 
       while (__len > 0) {
 	__half = __len >> 1;
@@ -2892,27 +2895,28 @@ __result, __binary_pred, _IterType());
    *  @param  last    Another iterator.
    *  @param  val     The search term.
    *  @param  comp    A functor to use for comparisons.
-   *  @return  An iterator pointing to the first element greater than @a val.
+   *  @return  An iterator pointing to the first element greater than @a val,
+   *           or end() if no elements are greater than @a val.
    *  @ingroup binarysearch
    *
    *  The comparison function should have the same effects on ordering as
    *  the function used for the initial sort.
   */
-  template<typename _ForwardIter, typename _Tp, typename _Compare>
-    _ForwardIter
-    upper_bound(_ForwardIter __first, _ForwardIter __last,
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    _ForwardIterator
+    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
 		const _Tp& __val, _Compare __comp)
     {
-      typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
-      typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;
+      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
 
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _ValueType>)
 
       _DistanceType __len = std::distance(__first, __last);
       _DistanceType __half;
-      _ForwardIter __middle;
+      _ForwardIterator __middle;
 
       while (__len > 0) {
 	__half = __len >> 1;
@@ -2945,22 +2949,22 @@ __result, __binary_pred, _IterType());
    *  @endcode
    *  but does not actually call those functions.
   */
-  template<typename _ForwardIter, typename _Tp>
-    pair<_ForwardIter, _ForwardIter>
-    equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val)
+  template<typename _ForwardIterator, typename _Tp>
+    pair<_ForwardIterator, _ForwardIterator>
+    equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val)
     {
-      typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
-      typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;
+      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
 
       // concept requirements
       // See comments on lower_bound.
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_SameTypeConcept<_Tp, _ValueType>)
       __glibcpp_function_requires(_LessThanComparableConcept<_Tp>)
 
       _DistanceType __len = std::distance(__first, __last);
       _DistanceType __half;
-      _ForwardIter __middle, __left, __right;
+      _ForwardIterator __middle, __left, __right;
 
       while (__len > 0) {
 	__half = __len >> 1;
@@ -2977,10 +2981,10 @@ __result, __binary_pred, _IterType());
 	  __left = lower_bound(__first, __middle, __val);
 	  advance(__first, __len);
 	  __right = upper_bound(++__middle, __first, __val);
-	  return pair<_ForwardIter, _ForwardIter>(__left, __right);
+	  return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
 	}
       }
-      return pair<_ForwardIter, _ForwardIter>(__first, __first);
+      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
     }
 
   /**
@@ -3000,22 +3004,22 @@ __result, __binary_pred, _IterType());
    *  @endcode
    *  but does not actually call those functions.
   */
-  template<typename _ForwardIter, typename _Tp, typename _Compare>
-    pair<_ForwardIter, _ForwardIter>
-    equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    pair<_ForwardIterator, _ForwardIterator>
+    equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val,
 		_Compare __comp)
     {
-      typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
-      typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;
+      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
 
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _ValueType, _Tp>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _ValueType>)
 
       _DistanceType __len = std::distance(__first, __last);
       _DistanceType __half;
-      _ForwardIter __middle, __left, __right;
+      _ForwardIterator __middle, __left, __right;
 
       while (__len > 0) {
 	__half = __len >> 1;
@@ -3032,10 +3036,10 @@ __result, __binary_pred, _IterType());
 	  __left = lower_bound(__first, __middle, __val, __comp);
 	  advance(__first, __len);
 	  __right = upper_bound(++__middle, __first, __val, __comp);
-	  return pair<_ForwardIter, _ForwardIter>(__left, __right);
+	  return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
 	}
       }
-      return pair<_ForwardIter, _ForwardIter>(__first, __first);
+      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
     }
 
   /**
@@ -3049,19 +3053,19 @@ __result, __binary_pred, _IterType());
    *  Note that this does not actually return an iterator to @a val.  For
    *  that, use std::find or a container's specialized find member functions.
   */
-  template<typename _ForwardIter, typename _Tp>
+  template<typename _ForwardIterator, typename _Tp>
     bool
-    binary_search(_ForwardIter __first, _ForwardIter __last,
+    binary_search(_ForwardIterator __first, _ForwardIterator __last,
                   const _Tp& __val)
     {
       // concept requirements
       // See comments on lower_bound.
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_SameTypeConcept<_Tp,
-		typename iterator_traits<_ForwardIter>::value_type>)
+		typename iterator_traits<_ForwardIterator>::value_type>)
       __glibcpp_function_requires(_LessThanComparableConcept<_Tp>)
 
-      _ForwardIter __i = lower_bound(__first, __last, __val);
+      _ForwardIterator __i = lower_bound(__first, __last, __val);
       return __i != __last && !(__val < *__i);
     }
 
@@ -3080,19 +3084,19 @@ __result, __binary_pred, _IterType());
    *  The comparison function should have the same effects on ordering as
    *  the function used for the initial sort.
   */
-  template<typename _ForwardIter, typename _Tp, typename _Compare>
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
     bool
-    binary_search(_ForwardIter __first, _ForwardIter __last,
+    binary_search(_ForwardIterator __first, _ForwardIterator __last,
                   const _Tp& __val, _Compare __comp)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
-		typename iterator_traits<_ForwardIter>::value_type, _Tp>)
+		typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp,
-		typename iterator_traits<_ForwardIter>::value_type>)
+		typename iterator_traits<_ForwardIterator>::value_type>)
 
-      _ForwardIter __i = lower_bound(__first, __last, __val, __comp);
+      _ForwardIterator __i = lower_bound(__first, __last, __val, __comp);
       return __i != __last && !__comp(__val, *__i);
     }
 
@@ -3112,22 +3116,22 @@ __result, __binary_pred, _IterType());
    *  elements in the two ranges, elements from the first range will always
    *  come before elements from the second.
   */
-  template<typename _InputIter1, typename _InputIter2, typename _OutputIter>
-    _OutputIter
-    merge(_InputIter1 __first1, _InputIter1 __last1,
-	  _InputIter2 __first2, _InputIter2 __last2,
-	  _OutputIter __result)
+  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator>
+    _OutputIterator
+    merge(_InputIterator1 __first1, _InputIterator1 __last1,
+	  _InputIterator2 __first2, _InputIterator2 __last2,
+	  _OutputIterator __result)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-	    typename iterator_traits<_InputIter1>::value_type>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
       __glibcpp_function_requires(_SameTypeConcept<
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
       __glibcpp_function_requires(_LessThanComparableConcept<
-	    typename iterator_traits<_InputIter1>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type>)
 
       while (__first1 != __last1 && __first2 != __last2) {
 	if (*__first2 < *__first1) {
@@ -3163,24 +3167,24 @@ __result, __binary_pred, _IterType());
    *  The comparison function should have the same effects on ordering as
    *  the function used for the initial sort.
   */
-  template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
+  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
 	   typename _Compare>
-    _OutputIter
-    merge(_InputIter1 __first1, _InputIter1 __last1,
-	  _InputIter2 __first2, _InputIter2 __last2,
-	  _OutputIter __result, _Compare __comp)
+    _OutputIterator
+    merge(_InputIterator1 __first1, _InputIterator1 __last1,
+	  _InputIterator2 __first2, _InputIterator2 __last2,
+	  _OutputIterator __result, _Compare __comp)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
       __glibcpp_function_requires(_SameTypeConcept<
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-	    typename iterator_traits<_InputIter1>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
 
       while (__first1 != __last1 && __first2 != __last2) {
 	if (__comp(*__first2, *__first1)) {
@@ -3201,11 +3205,11 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the merge routines.
    *  @endif
   */
-  template<typename _BidirectionalIter, typename _Distance>
+  template<typename _BidirectionalIterator, typename _Distance>
     void
-    __merge_without_buffer(_BidirectionalIter __first,
-			   _BidirectionalIter __middle,
-			   _BidirectionalIter __last,
+    __merge_without_buffer(_BidirectionalIterator __first,
+			   _BidirectionalIterator __middle,
+			   _BidirectionalIterator __last,
 			   _Distance __len1, _Distance __len2)
     {
       if (__len1 == 0 || __len2 == 0)
@@ -3215,8 +3219,8 @@ __result, __binary_pred, _IterType());
 	      iter_swap(__first, __middle);
 	return;
       }
-      _BidirectionalIter __first_cut = __first;
-      _BidirectionalIter __second_cut = __middle;
+      _BidirectionalIterator __first_cut = __first;
+      _BidirectionalIterator __second_cut = __middle;
       _Distance __len11 = 0;
       _Distance __len22 = 0;
       if (__len1 > __len2) {
@@ -3232,7 +3236,7 @@ __result, __binary_pred, _IterType());
 	__len11 = std::distance(__first, __first_cut);
       }
       rotate(__first_cut, __middle, __second_cut);
-      _BidirectionalIter __new_middle = __first_cut;
+      _BidirectionalIterator __new_middle = __first_cut;
       advance(__new_middle, std::distance(__middle, __second_cut));
       __merge_without_buffer(__first, __first_cut, __new_middle,
 			     __len11, __len22);
@@ -3245,11 +3249,11 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the merge routines.
    *  @endif
   */
-  template<typename _BidirectionalIter, typename _Distance, typename _Compare>
+  template<typename _BidirectionalIterator, typename _Distance, typename _Compare>
     void
-    __merge_without_buffer(_BidirectionalIter __first,
-                           _BidirectionalIter __middle,
-			   _BidirectionalIter __last,
+    __merge_without_buffer(_BidirectionalIterator __first,
+                           _BidirectionalIterator __middle,
+			   _BidirectionalIterator __last,
 			   _Distance __len1, _Distance __len2,
 			   _Compare __comp)
     {
@@ -3260,8 +3264,8 @@ __result, __binary_pred, _IterType());
 	      iter_swap(__first, __middle);
 	return;
       }
-      _BidirectionalIter __first_cut = __first;
-      _BidirectionalIter __second_cut = __middle;
+      _BidirectionalIterator __first_cut = __first;
+      _BidirectionalIterator __second_cut = __middle;
       _Distance __len11 = 0;
       _Distance __len22 = 0;
       if (__len1 > __len2) {
@@ -3277,7 +3281,7 @@ __result, __binary_pred, _IterType());
 	__len11 = std::distance(__first, __first_cut);
       }
       rotate(__first_cut, __middle, __second_cut);
-      _BidirectionalIter __new_middle = __first_cut;
+      _BidirectionalIterator __new_middle = __first_cut;
       advance(__new_middle, std::distance(__middle, __second_cut));
       __merge_without_buffer(__first, __first_cut, __new_middle,
 			     __len11, __len22, __comp);
@@ -3290,17 +3294,17 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the merge routines.
    *  @endif
   */
-  template<typename _BidirectionalIter1, typename _BidirectionalIter2,
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
 	   typename _Distance>
-    _BidirectionalIter1
-    __rotate_adaptive(_BidirectionalIter1 __first,
-		      _BidirectionalIter1 __middle,
-		      _BidirectionalIter1 __last,
+    _BidirectionalIterator1
+    __rotate_adaptive(_BidirectionalIterator1 __first,
+		      _BidirectionalIterator1 __middle,
+		      _BidirectionalIterator1 __last,
 		      _Distance __len1, _Distance __len2,
-		      _BidirectionalIter2 __buffer,
+		      _BidirectionalIterator2 __buffer,
 		      _Distance __buffer_size)
     {
-      _BidirectionalIter2 __buffer_end;
+      _BidirectionalIterator2 __buffer_end;
       if (__len1 > __len2 && __len2 <= __buffer_size) {
 	__buffer_end = copy(__middle, __last, __buffer);
 	copy_backward(__first, __middle, __last);
@@ -3323,12 +3327,12 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the merge routines.
    *  @endif
   */
-  template<typename _BidirectionalIter1, typename _BidirectionalIter2,
-	   typename _BidirectionalIter3>
-    _BidirectionalIter3
-    __merge_backward(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
-		     _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
-		     _BidirectionalIter3 __result)
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+	   typename _BidirectionalIterator3>
+    _BidirectionalIterator3
+    __merge_backward(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1,
+		     _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2,
+		     _BidirectionalIterator3 __result)
     {
       if (__first1 == __last1)
 	return copy_backward(__first2, __last2, __result);
@@ -3357,12 +3361,12 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the merge routines.
    *  @endif
   */
-  template<typename _BidirectionalIter1, typename _BidirectionalIter2,
-	   typename _BidirectionalIter3, typename _Compare>
-    _BidirectionalIter3
-    __merge_backward(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
-		     _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
-		     _BidirectionalIter3 __result,
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+	   typename _BidirectionalIterator3, typename _Compare>
+    _BidirectionalIterator3
+    __merge_backward(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1,
+		     _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2,
+		     _BidirectionalIterator3 __result,
 		     _Compare __comp)
     {
       if (__first1 == __last1)
@@ -3392,11 +3396,11 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the merge routines.
    *  @endif
   */
-  template<typename _BidirectionalIter, typename _Distance, typename _Pointer>
+  template<typename _BidirectionalIterator, typename _Distance, typename _Pointer>
     void
-    __merge_adaptive(_BidirectionalIter __first,
-                     _BidirectionalIter __middle,
-		     _BidirectionalIter __last,
+    __merge_adaptive(_BidirectionalIterator __first,
+                     _BidirectionalIterator __middle,
+		     _BidirectionalIterator __last,
 		     _Distance __len1, _Distance __len2,
 		     _Pointer __buffer, _Distance __buffer_size)
     {
@@ -3409,8 +3413,8 @@ __result, __binary_pred, _IterType());
 	    __merge_backward(__first, __middle, __buffer, __buffer_end, __last);
 	  }
 	  else {
-	    _BidirectionalIter __first_cut = __first;
-	    _BidirectionalIter __second_cut = __middle;
+	    _BidirectionalIterator __first_cut = __first;
+	    _BidirectionalIterator __second_cut = __middle;
 	    _Distance __len11 = 0;
 	    _Distance __len22 = 0;
 	    if (__len1 > __len2) {
@@ -3425,7 +3429,7 @@ __result, __binary_pred, _IterType());
 		  __first_cut = upper_bound(__first, __middle, *__second_cut);
 		  __len11 = std::distance(__first, __first_cut);
 	    }
-	    _BidirectionalIter __new_middle =
+	    _BidirectionalIterator __new_middle =
 		  __rotate_adaptive(__first_cut, __middle, __second_cut,
 				    __len1 - __len11, __len22, __buffer,
 				    __buffer_size);
@@ -3441,12 +3445,12 @@ __result, __binary_pred, _IterType());
    *  This is a helper function for the merge routines.
    *  @endif
   */
-  template<typename _BidirectionalIter, typename _Distance, typename _Pointer,
+  template<typename _BidirectionalIterator, typename _Distance, typename _Pointer,
 	   typename _Compare>
     void
-    __merge_adaptive(_BidirectionalIter __first,
-                     _BidirectionalIter __middle,
-		     _BidirectionalIter __last,
+    __merge_adaptive(_BidirectionalIterator __first,
+                     _BidirectionalIterator __middle,
+		     _BidirectionalIterator __last,
 		     _Distance __len1, _Distance __len2,
 		     _Pointer __buffer, _Distance __buffer_size,
 		     _Compare __comp)
@@ -3461,8 +3465,8 @@ __result, __binary_pred, _IterType());
 					     __comp);
 	  }
 	  else {
-	    _BidirectionalIter __first_cut = __first;
-	    _BidirectionalIter __second_cut = __middle;
+	    _BidirectionalIterator __first_cut = __first;
+	    _BidirectionalIterator __second_cut = __middle;
 	    _Distance __len11 = 0;
 	    _Distance __len22 = 0;
 	    if (__len1 > __len2) {
@@ -3477,7 +3481,7 @@ __result, __binary_pred, _IterType());
 		  __first_cut = upper_bound(__first, __middle, *__second_cut, __comp);
 		  __len11 = std::distance(__first, __first_cut);
 	    }
-	    _BidirectionalIter __new_middle =
+	    _BidirectionalIterator __new_middle =
 		  __rotate_adaptive(__first_cut, __middle, __second_cut,
 				    __len1 - __len11, __len22, __buffer,
 				    __buffer_size);
@@ -3505,20 +3509,20 @@ __result, __binary_pred, _IterType());
    *  comparisons.  Otherwise an NlogN algorithm is used, where N is
    *  distance(first,last).
   */
-  template<typename _BidirectionalIter>
+  template<typename _BidirectionalIterator>
     void
-    inplace_merge(_BidirectionalIter __first,
-		  _BidirectionalIter __middle,
-		  _BidirectionalIter __last)
+    inplace_merge(_BidirectionalIterator __first,
+		  _BidirectionalIterator __middle,
+		  _BidirectionalIterator __last)
     {
-      typedef typename iterator_traits<_BidirectionalIter>::value_type
+      typedef typename iterator_traits<_BidirectionalIterator>::value_type
           _ValueType;
-      typedef typename iterator_traits<_BidirectionalIter>::difference_type
+      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
           _DistanceType;
 
       // concept requirements
       __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<
-	    _BidirectionalIter>)
+	    _BidirectionalIterator>)
       __glibcpp_function_requires(_LessThanComparableConcept<_ValueType>)
 
       if (__first == __middle || __middle == __last)
@@ -3527,7 +3531,7 @@ __result, __binary_pred, _IterType());
       _DistanceType __len1 = std::distance(__first, __middle);
       _DistanceType __len2 = std::distance(__middle, __last);
 
-      _Temporary_buffer<_BidirectionalIter, _ValueType> __buf(__first, __last);
+      _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first, __last);
       if (__buf.begin() == 0)
 	__merge_without_buffer(__first, __middle, __last, __len1, __len2);
       else
@@ -3556,21 +3560,21 @@ __result, __binary_pred, _IterType());
    *  The comparison function should have the same effects on ordering as
    *  the function used for the initial sort.
   */
-  template<typename _BidirectionalIter, typename _Compare>
+  template<typename _BidirectionalIterator, typename _Compare>
     void
-    inplace_merge(_BidirectionalIter __first,
-		  _BidirectionalIter __middle,
-		  _BidirectionalIter __last,
+    inplace_merge(_BidirectionalIterator __first,
+		  _BidirectionalIterator __middle,
+		  _BidirectionalIterator __last,
 		  _Compare __comp)
     {
-      typedef typename iterator_traits<_BidirectionalIter>::value_type
+      typedef typename iterator_traits<_BidirectionalIterator>::value_type
           _ValueType;
-      typedef typename iterator_traits<_BidirectionalIter>::difference_type
+      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
           _DistanceType;
 
       // concept requirements
       __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<
-	    _BidirectionalIter>)
+	    _BidirectionalIterator>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
 	    _ValueType, _ValueType>)
 
@@ -3580,7 +3584,7 @@ __result, __binary_pred, _IterType());
       _DistanceType __len1 = std::distance(__first, __middle);
       _DistanceType __len2 = std::distance(__middle, __last);
 
-      _Temporary_buffer<_BidirectionalIter, _ValueType> __buf(__first, __last);
+      _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first, __last);
       if (__buf.begin() == 0)
 	__merge_without_buffer(__first, __middle, __last, __len1, __len2, __comp);
       else
@@ -3594,19 +3598,19 @@ __result, __binary_pred, _IterType());
   // that their input ranges are sorted and the postcondition that their output
   // ranges are sorted.
 
-  template<typename _InputIter1, typename _InputIter2>
+  template<typename _InputIterator1, typename _InputIterator2>
     bool
-    includes(_InputIter1 __first1, _InputIter1 __last1,
-	     _InputIter2 __first2, _InputIter2 __last2)
+    includes(_InputIterator1 __first1, _InputIterator1 __last1,
+	     _InputIterator2 __first2, _InputIterator2 __last2)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
       __glibcpp_function_requires(_SameTypeConcept<
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
       __glibcpp_function_requires(_LessThanComparableConcept<
-	    typename iterator_traits<_InputIter1>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type>)
 
       while (__first1 != __last1 && __first2 != __last2)
 	if (*__first2 < *__first1)
@@ -3619,20 +3623,20 @@ __result, __binary_pred, _IterType());
       return __first2 == __last2;
     }
 
-  template<typename _InputIter1, typename _InputIter2, typename _Compare>
+  template<typename _InputIterator1, typename _InputIterator2, typename _Compare>
     bool
-    includes(_InputIter1 __first1, _InputIter1 __last1,
-	     _InputIter2 __first2, _InputIter2 __last2, _Compare __comp)
+    includes(_InputIterator1 __first1, _InputIterator1 __last1,
+	     _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
       __glibcpp_function_requires(_SameTypeConcept<
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
 
       while (__first1 != __last1 && __first2 != __last2)
 	if (__comp(*__first2, *__first1))
@@ -3645,22 +3649,22 @@ __result, __binary_pred, _IterType());
       return __first2 == __last2;
     }
 
-  template<typename _InputIter1, typename _InputIter2, typename _OutputIter>
-    _OutputIter
-    set_union(_InputIter1 __first1, _InputIter1 __last1,
-	      _InputIter2 __first2, _InputIter2 __last2,
-	      _OutputIter __result)
+  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator>
+    _OutputIterator
+    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+	      _InputIterator2 __first2, _InputIterator2 __last2,
+	      _OutputIterator __result)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-	    typename iterator_traits<_InputIter1>::value_type>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
       __glibcpp_function_requires(_SameTypeConcept<
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
       __glibcpp_function_requires(_LessThanComparableConcept<
-	    typename iterator_traits<_InputIter1>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type>)
 
       while (__first1 != __last1 && __first2 != __last2) {
 	if (*__first1 < *__first2) {
@@ -3681,24 +3685,24 @@ __result, __binary_pred, _IterType());
       return copy(__first2, __last2, copy(__first1, __last1, __result));
     }
 
-  template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
+  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
 	   typename _Compare>
-    _OutputIter
-    set_union(_InputIter1 __first1, _InputIter1 __last1,
-	      _InputIter2 __first2, _InputIter2 __last2,
-	      _OutputIter __result, _Compare __comp)
+    _OutputIterator
+    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+	      _InputIterator2 __first2, _InputIterator2 __last2,
+	      _OutputIterator __result, _Compare __comp)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
       __glibcpp_function_requires(_SameTypeConcept<
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-	    typename iterator_traits<_InputIter1>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
 
       while (__first1 != __last1 && __first2 != __last2) {
 	if (__comp(*__first1, *__first2)) {
@@ -3719,22 +3723,22 @@ __result, __binary_pred, _IterType());
       return copy(__first2, __last2, copy(__first1, __last1, __result));
     }
 
-  template<typename _InputIter1, typename _InputIter2, typename _OutputIter>
-    _OutputIter
-    set_intersection(_InputIter1 __first1, _InputIter1 __last1,
-		     _InputIter2 __first2, _InputIter2 __last2,
-		     _OutputIter __result)
+  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator>
+    _OutputIterator
+    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+		     _InputIterator2 __first2, _InputIterator2 __last2,
+		     _OutputIterator __result)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-	    typename iterator_traits<_InputIter1>::value_type>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
       __glibcpp_function_requires(_SameTypeConcept<
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
       __glibcpp_function_requires(_LessThanComparableConcept<
-	    typename iterator_traits<_InputIter1>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type>)
 
       while (__first1 != __last1 && __first2 != __last2)
 	if (*__first1 < *__first2)
@@ -3750,24 +3754,24 @@ __result, __binary_pred, _IterType());
       return __result;
     }
 
-  template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
+  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
 	   typename _Compare>
-    _OutputIter
-    set_intersection(_InputIter1 __first1, _InputIter1 __last1,
-		     _InputIter2 __first2, _InputIter2 __last2,
-		     _OutputIter __result, _Compare __comp)
+    _OutputIterator
+    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+		     _InputIterator2 __first2, _InputIterator2 __last2,
+		     _OutputIterator __result, _Compare __comp)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
       __glibcpp_function_requires(_SameTypeConcept<
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-	    typename iterator_traits<_InputIter1>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
 
       while (__first1 != __last1 && __first2 != __last2)
 	if (__comp(*__first1, *__first2))
@@ -3783,22 +3787,22 @@ __result, __binary_pred, _IterType());
       return __result;
     }
 
-  template<typename _InputIter1, typename _InputIter2, typename _OutputIter>
-    _OutputIter
-    set_difference(_InputIter1 __first1, _InputIter1 __last1,
-		   _InputIter2 __first2, _InputIter2 __last2,
-		   _OutputIter __result)
+  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator>
+    _OutputIterator
+    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+		   _InputIterator2 __first2, _InputIterator2 __last2,
+		   _OutputIterator __result)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-	    typename iterator_traits<_InputIter1>::value_type>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
       __glibcpp_function_requires(_SameTypeConcept<
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
       __glibcpp_function_requires(_LessThanComparableConcept<
-	    typename iterator_traits<_InputIter1>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type>)
 
       while (__first1 != __last1 && __first2 != __last2)
 	if (*__first1 < *__first2) {
@@ -3815,24 +3819,24 @@ __result, __binary_pred, _IterType());
       return copy(__first1, __last1, __result);
     }
 
-  template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
+  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
 	   typename _Compare>
-    _OutputIter
-    set_difference(_InputIter1 __first1, _InputIter1 __last1,
-		   _InputIter2 __first2, _InputIter2 __last2,
-		   _OutputIter __result, _Compare __comp)
+    _OutputIterator
+    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+		   _InputIterator2 __first2, _InputIterator2 __last2,
+		   _OutputIterator __result, _Compare __comp)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
       __glibcpp_function_requires(_SameTypeConcept<
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-	    typename iterator_traits<_InputIter1>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
 
       while (__first1 != __last1 && __first2 != __last2)
 	if (__comp(*__first1, *__first2)) {
@@ -3849,22 +3853,22 @@ __result, __binary_pred, _IterType());
       return copy(__first1, __last1, __result);
     }
 
-  template<typename _InputIter1, typename _InputIter2, typename _OutputIter>
-    _OutputIter
-    set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
-			     _InputIter2 __first2, _InputIter2 __last2,
-			     _OutputIter __result)
+  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator>
+    _OutputIterator
+    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+			     _InputIterator2 __first2, _InputIterator2 __last2,
+			     _OutputIterator __result)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-	    typename iterator_traits<_InputIter1>::value_type>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
       __glibcpp_function_requires(_SameTypeConcept<
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
       __glibcpp_function_requires(_LessThanComparableConcept<
-	    typename iterator_traits<_InputIter1>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type>)
 
       while (__first1 != __last1 && __first2 != __last2)
 	if (*__first1 < *__first2) {
@@ -3884,25 +3888,25 @@ __result, __binary_pred, _IterType());
       return copy(__first2, __last2, copy(__first1, __last1, __result));
     }
 
-  template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
+  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
 	   typename _Compare>
-    _OutputIter
-    set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
-			     _InputIter2 __first2, _InputIter2 __last2,
-			     _OutputIter __result,
+    _OutputIterator
+    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+			     _InputIterator2 __first2, _InputIterator2 __last2,
+			     _OutputIterator __result,
 			     _Compare __comp)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
       __glibcpp_function_requires(_SameTypeConcept<
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-	    typename iterator_traits<_InputIter1>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
 
       while (__first1 != __last1 && __first2 != __last2)
 	if (__comp(*__first1, *__first2)) {
@@ -3925,71 +3929,71 @@ __result, __binary_pred, _IterType());
   // min_element and max_element, with and without an explicitly supplied
   // comparison function.
 
-  template<typename _ForwardIter>
-    _ForwardIter
-    max_element(_ForwardIter __first, _ForwardIter __last)
+  template<typename _ForwardIterator>
+    _ForwardIterator
+    max_element(_ForwardIterator __first, _ForwardIterator __last)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_LessThanComparableConcept<
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_ForwardIterator>::value_type>)
 
       if (__first == __last) return __first;
-      _ForwardIter __result = __first;
+      _ForwardIterator __result = __first;
       while (++__first != __last)
 	if (*__result < *__first)
 	  __result = __first;
       return __result;
     }
 
-  template<typename _ForwardIter, typename _Compare>
-    _ForwardIter
-    max_element(_ForwardIter __first, _ForwardIter __last,
+  template<typename _ForwardIterator, typename _Compare>
+    _ForwardIterator
+    max_element(_ForwardIterator __first, _ForwardIterator __last,
 		_Compare __comp)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
-	    typename iterator_traits<_ForwardIter>::value_type,
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_ForwardIterator>::value_type,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
 
       if (__first == __last) return __first;
-      _ForwardIter __result = __first;
+      _ForwardIterator __result = __first;
       while (++__first != __last)
 	if (__comp(*__result, *__first)) __result = __first;
       return __result;
     }
 
-  template<typename _ForwardIter>
-    _ForwardIter
-    min_element(_ForwardIter __first, _ForwardIter __last)
+  template<typename _ForwardIterator>
+    _ForwardIterator
+    min_element(_ForwardIterator __first, _ForwardIterator __last)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_LessThanComparableConcept<
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_ForwardIterator>::value_type>)
 
       if (__first == __last) return __first;
-      _ForwardIter __result = __first;
+      _ForwardIterator __result = __first;
       while (++__first != __last)
 	if (*__first < *__result)
 	  __result = __first;
       return __result;
     }
 
-  template<typename _ForwardIter, typename _Compare>
-    _ForwardIter
-    min_element(_ForwardIter __first, _ForwardIter __last,
+  template<typename _ForwardIterator, typename _Compare>
+    _ForwardIterator
+    min_element(_ForwardIterator __first, _ForwardIterator __last,
 		_Compare __comp)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
-	    typename iterator_traits<_ForwardIter>::value_type,
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_ForwardIterator>::value_type,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
 
       if (__first == __last) return __first;
-      _ForwardIter __result = __first;
+      _ForwardIterator __result = __first;
       while (++__first != __last)
 	if (__comp(*__first, *__result))
 	  __result = __first;
@@ -3999,18 +4003,18 @@ __result, __binary_pred, _IterType());
   // next_permutation and prev_permutation, with and without an explicitly
   // supplied comparison function.
 
-  template<typename _BidirectionalIter>
+  template<typename _BidirectionalIterator>
     bool
-    next_permutation(_BidirectionalIter __first, _BidirectionalIter __last)
+    next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
     {
       // concept requirements
-      __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>)
+      __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
       __glibcpp_function_requires(_LessThanComparableConcept<
-	    typename iterator_traits<_BidirectionalIter>::value_type>)
+	    typename iterator_traits<_BidirectionalIterator>::value_type>)
 
       if (__first == __last)
 	return false;
-      _BidirectionalIter __i = __first;
+      _BidirectionalIterator __i = __first;
       ++__i;
       if (__i == __last)
 	return false;
@@ -4018,10 +4022,10 @@ __result, __binary_pred, _IterType());
       --__i;
 
       for(;;) {
-	_BidirectionalIter __ii = __i;
+	_BidirectionalIterator __ii = __i;
 	--__i;
 	if (*__i < *__ii) {
-	  _BidirectionalIter __j = __last;
+	  _BidirectionalIterator __j = __last;
 	  while (!(*__i < *--__j))
 	    {}
 	  iter_swap(__i, __j);
@@ -4035,20 +4039,20 @@ __result, __binary_pred, _IterType());
       }
     }
 
-  template<typename _BidirectionalIter, typename _Compare>
+  template<typename _BidirectionalIterator, typename _Compare>
     bool
-    next_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
+    next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last,
 		     _Compare __comp)
     {
       // concept requirements
-      __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>)
+      __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
-	    typename iterator_traits<_BidirectionalIter>::value_type,
-	    typename iterator_traits<_BidirectionalIter>::value_type>)
+	    typename iterator_traits<_BidirectionalIterator>::value_type,
+	    typename iterator_traits<_BidirectionalIterator>::value_type>)
 
       if (__first == __last)
 	return false;
-      _BidirectionalIter __i = __first;
+      _BidirectionalIterator __i = __first;
       ++__i;
       if (__i == __last)
 	return false;
@@ -4056,10 +4060,10 @@ __result, __binary_pred, _IterType());
       --__i;
 
       for(;;) {
-	_BidirectionalIter __ii = __i;
+	_BidirectionalIterator __ii = __i;
 	--__i;
 	if (__comp(*__i, *__ii)) {
-	  _BidirectionalIter __j = __last;
+	  _BidirectionalIterator __j = __last;
 	  while (!__comp(*__i, *--__j))
 	    {}
 	  iter_swap(__i, __j);
@@ -4073,18 +4077,18 @@ __result, __binary_pred, _IterType());
       }
     }
 
-  template<typename _BidirectionalIter>
+  template<typename _BidirectionalIterator>
     bool
-    prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last)
+    prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
     {
       // concept requirements
-      __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>)
+      __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
       __glibcpp_function_requires(_LessThanComparableConcept<
-	    typename iterator_traits<_BidirectionalIter>::value_type>)
+	    typename iterator_traits<_BidirectionalIterator>::value_type>)
 
       if (__first == __last)
 	return false;
-      _BidirectionalIter __i = __first;
+      _BidirectionalIterator __i = __first;
       ++__i;
       if (__i == __last)
 	return false;
@@ -4092,10 +4096,10 @@ __result, __binary_pred, _IterType());
       --__i;
 
       for(;;) {
-	_BidirectionalIter __ii = __i;
+	_BidirectionalIterator __ii = __i;
 	--__i;
 	if (*__ii < *__i) {
-	  _BidirectionalIter __j = __last;
+	  _BidirectionalIterator __j = __last;
 	  while (!(*--__j < *__i))
 	    {}
 	  iter_swap(__i, __j);
@@ -4109,20 +4113,20 @@ __result, __binary_pred, _IterType());
       }
     }
 
-  template<typename _BidirectionalIter, typename _Compare>
+  template<typename _BidirectionalIterator, typename _Compare>
     bool
-    prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
+    prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last,
 		     _Compare __comp)
     {
       // concept requirements
-      __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>)
+      __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
-	    typename iterator_traits<_BidirectionalIter>::value_type,
-	    typename iterator_traits<_BidirectionalIter>::value_type>)
+	    typename iterator_traits<_BidirectionalIterator>::value_type,
+	    typename iterator_traits<_BidirectionalIterator>::value_type>)
 
       if (__first == __last)
 	return false;
-      _BidirectionalIter __i = __first;
+      _BidirectionalIterator __i = __first;
       ++__i;
       if (__i == __last)
 	return false;
@@ -4130,10 +4134,10 @@ __result, __binary_pred, _IterType());
       --__i;
 
       for(;;) {
-	_BidirectionalIter __ii = __i;
+	_BidirectionalIterator __ii = __i;
 	--__i;
 	if (__comp(*__ii, *__i)) {
-	  _BidirectionalIter __j = __last;
+	  _BidirectionalIterator __j = __last;
 	  while (!__comp(*--__j, *__i))
 	    {}
 	  iter_swap(__i, __j);
@@ -4149,43 +4153,43 @@ __result, __binary_pred, _IterType());
 
   // find_first_of, with and without an explicitly supplied comparison function.
 
-  template<typename _InputIter, typename _ForwardIter>
-    _InputIter
-    find_first_of(_InputIter __first1, _InputIter __last1,
-		  _ForwardIter __first2, _ForwardIter __last2)
+  template<typename _InputIterator, typename _ForwardIterator>
+    _InputIterator
+    find_first_of(_InputIterator __first1, _InputIterator __last1,
+		  _ForwardIterator __first2, _ForwardIterator __last2)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_EqualOpConcept<
-	    typename iterator_traits<_InputIter>::value_type,
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_InputIterator>::value_type,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
 
       for ( ; __first1 != __last1; ++__first1)
-	for (_ForwardIter __iter = __first2; __iter != __last2; ++__iter)
+	for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
 	  if (*__first1 == *__iter)
 	    return __first1;
       return __last1;
     }
 
-  template<typename _InputIter, typename _ForwardIter, typename _BinaryPredicate>
-    _InputIter
-    find_first_of(_InputIter __first1, _InputIter __last1,
-		  _ForwardIter __first2, _ForwardIter __last2,
+  template<typename _InputIterator, typename _ForwardIterator, typename _BinaryPredicate>
+    _InputIterator
+    find_first_of(_InputIterator __first1, _InputIterator __last1,
+		  _ForwardIterator __first2, _ForwardIterator __last2,
 		  _BinaryPredicate __comp)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_EqualOpConcept<
-	    typename iterator_traits<_InputIter>::value_type,
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_InputIterator>::value_type,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
-	    typename iterator_traits<_InputIter>::value_type,
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_InputIterator>::value_type,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
 
       for ( ; __first1 != __last1; ++__first1)
-	for (_ForwardIter __iter = __first2; __iter != __last2; ++__iter)
+	for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
 	  if (__comp(*__first1, *__iter))
 	    return __first1;
       return __last1;
@@ -4198,18 +4202,18 @@ __result, __binary_pred, _IterType());
   // is much faster than for forward iterators.
 
   // find_end for forward iterators.
-  template<typename _ForwardIter1, typename _ForwardIter2>
-    _ForwardIter1
-    __find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
-	       _ForwardIter2 __first2, _ForwardIter2 __last2,
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    _ForwardIterator1
+    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+	       _ForwardIterator2 __first2, _ForwardIterator2 __last2,
 	       forward_iterator_tag, forward_iterator_tag)
     {
       if (__first2 == __last2)
 	return __last1;
       else {
-	_ForwardIter1 __result = __last1;
+	_ForwardIterator1 __result = __last1;
 	while (1) {
-	  _ForwardIter1 __new_result
+	  _ForwardIterator1 __new_result
 	    = search(__first1, __last1, __first2, __last2);
 	  if (__new_result == __last1)
 	    return __result;
@@ -4222,20 +4226,20 @@ __result, __binary_pred, _IterType());
       }
     }
 
-  template<typename _ForwardIter1, typename _ForwardIter2,
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
 	   typename _BinaryPredicate>
-    _ForwardIter1
-    __find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
-	       _ForwardIter2 __first2, _ForwardIter2 __last2,
+    _ForwardIterator1
+    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+	       _ForwardIterator2 __first2, _ForwardIterator2 __last2,
 	       forward_iterator_tag, forward_iterator_tag,
 	       _BinaryPredicate __comp)
     {
       if (__first2 == __last2)
 	return __last1;
       else {
-	_ForwardIter1 __result = __last1;
+	_ForwardIterator1 __result = __last1;
 	while (1) {
-	  _ForwardIter1 __new_result
+	  _ForwardIterator1 __new_result
 	    = search(__first1, __last1, __first2, __last2, __comp);
 	  if (__new_result == __last1)
 	    return __result;
@@ -4249,58 +4253,58 @@ __result, __binary_pred, _IterType());
     }
 
   // find_end for bidirectional iterators.  Requires partial specialization.
-  template<typename _BidirectionalIter1, typename _BidirectionalIter2>
-    _BidirectionalIter1
-    __find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
-	       _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
+    _BidirectionalIterator1
+    __find_end(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1,
+	       _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2,
 	       bidirectional_iterator_tag, bidirectional_iterator_tag)
     {
       // concept requirements
-      __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter1>)
-      __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter2>)
+      __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator1>)
+      __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator2>)
 
-      typedef reverse_iterator<_BidirectionalIter1> _RevIter1;
-      typedef reverse_iterator<_BidirectionalIter2> _RevIter2;
+      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
+      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
 
-      _RevIter1 __rlast1(__first1);
-      _RevIter2 __rlast2(__first2);
-      _RevIter1 __rresult = search(_RevIter1(__last1), __rlast1,
-				   _RevIter2(__last2), __rlast2);
+      _RevIterator1 __rlast1(__first1);
+      _RevIterator2 __rlast2(__first2);
+      _RevIterator1 __rresult = search(_RevIterator1(__last1), __rlast1,
+				   _RevIterator2(__last2), __rlast2);
 
       if (__rresult == __rlast1)
 	return __last1;
       else {
-	_BidirectionalIter1 __result = __rresult.base();
+	_BidirectionalIterator1 __result = __rresult.base();
 	advance(__result, -std::distance(__first2, __last2));
 	return __result;
       }
     }
 
-  template<typename _BidirectionalIter1, typename _BidirectionalIter2,
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
 	   typename _BinaryPredicate>
-    _BidirectionalIter1
-    __find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
-	       _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
+    _BidirectionalIterator1
+    __find_end(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1,
+	       _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2,
 	       bidirectional_iterator_tag, bidirectional_iterator_tag,
 	       _BinaryPredicate __comp)
     {
       // concept requirements
-      __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter1>)
-      __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter2>)
+      __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator1>)
+      __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator2>)
 
-      typedef reverse_iterator<_BidirectionalIter1> _RevIter1;
-      typedef reverse_iterator<_BidirectionalIter2> _RevIter2;
+      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
+      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
 
-      _RevIter1 __rlast1(__first1);
-      _RevIter2 __rlast2(__first2);
-      _RevIter1 __rresult = search(_RevIter1(__last1), __rlast1,
-				   _RevIter2(__last2), __rlast2,
+      _RevIterator1 __rlast1(__first1);
+      _RevIterator2 __rlast2(__first2);
+      _RevIterator1 __rresult = search(_RevIterator1(__last1), __rlast1,
+				   _RevIterator2(__last2), __rlast2,
 				   __comp);
 
       if (__rresult == __rlast1)
 	return __last1;
       else {
-	_BidirectionalIter1 __result = __rresult.base();
+	_BidirectionalIterator1 __result = __rresult.base();
 	advance(__result, -std::distance(__first2, __last2));
 	return __result;
       }
@@ -4308,36 +4312,36 @@ __result, __binary_pred, _IterType());
 
   // Dispatching functions for find_end.
 
-  template<typename _ForwardIter1, typename _ForwardIter2>
-    inline _ForwardIter1
-    find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
-	     _ForwardIter2 __first2, _ForwardIter2 __last2)
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline _ForwardIterator1
+    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+	     _ForwardIterator2 __first2, _ForwardIterator2 __last2)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>)
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
       __glibcpp_function_requires(_EqualOpConcept<
-	    typename iterator_traits<_ForwardIter1>::value_type,
-	    typename iterator_traits<_ForwardIter2>::value_type>)
+	    typename iterator_traits<_ForwardIterator1>::value_type,
+	    typename iterator_traits<_ForwardIterator2>::value_type>)
 
       return __find_end(__first1, __last1, __first2, __last2,
 			__iterator_category(__first1),
 			__iterator_category(__first2));
     }
 
-  template<typename _ForwardIter1, typename _ForwardIter2,
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
 	   typename _BinaryPredicate>
-    inline _ForwardIter1
-    find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
-	     _ForwardIter2 __first2, _ForwardIter2 __last2,
+    inline _ForwardIterator1
+    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+	     _ForwardIterator2 __first2, _ForwardIterator2 __last2,
 	     _BinaryPredicate __comp)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>)
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
-	    typename iterator_traits<_ForwardIter1>::value_type,
-	    typename iterator_traits<_ForwardIter2>::value_type>)
+	    typename iterator_traits<_ForwardIterator1>::value_type,
+	    typename iterator_traits<_ForwardIterator2>::value_type>)
 
       return __find_end(__first1, __last1, __first2, __last2,
 			__iterator_category(__first1),
diff --git a/libstdc++-v3/include/bits/stl_algobase.h b/libstdc++-v3/include/bits/stl_algobase.h
index c5ba0d4ce35..a65e8952e4d 100644
--- a/libstdc++-v3/include/bits/stl_algobase.h
+++ b/libstdc++-v3/include/bits/stl_algobase.h
@@ -86,16 +86,16 @@ namespace std
    *  This function swaps the values pointed to by two iterators, not the
    *  iterators themselves.
   */
-  template<typename _ForwardIter1, typename _ForwardIter2>
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
     inline void
-    iter_swap(_ForwardIter1 __a, _ForwardIter2 __b)
+    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
     {
-      typedef typename iterator_traits<_ForwardIter1>::value_type _ValueType1;
-      typedef typename iterator_traits<_ForwardIter2>::value_type _ValueType2;
+      typedef typename iterator_traits<_ForwardIterator1>::value_type _ValueType1;
+      typedef typename iterator_traits<_ForwardIterator2>::value_type _ValueType2;
 
       // concept requirements
-      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter1>)
-      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter2>)
+      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator1>)
+      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator2>)
       __glibcpp_function_requires(_ConvertibleConcept<_ValueType1, _ValueType2>)
       __glibcpp_function_requires(_ConvertibleConcept<_ValueType2, _ValueType1>)
 
@@ -210,22 +210,22 @@ namespace std
   // (2) If we're using random access iterators, then write the loop as
   // a for loop with an explicit count.
 
-  template<typename _InputIter, typename _OutputIter>
-    inline _OutputIter
-    __copy(_InputIter __first, _InputIter __last,
-	   _OutputIter __result, input_iterator_tag)
+  template<typename _InputIterator, typename _OutputIterator>
+    inline _OutputIterator
+    __copy(_InputIterator __first, _InputIterator __last,
+	   _OutputIterator __result, input_iterator_tag)
     {
       for (; __first != __last; ++__result, ++__first)
 	*__result = *__first;
       return __result;
     }
 
-  template<typename _RandomAccessIter, typename _OutputIter>
-    inline _OutputIter
-    __copy(_RandomAccessIter __first, _RandomAccessIter __last,
-	   _OutputIter __result, random_access_iterator_tag)
+  template<typename _RandomAccessIterator, typename _OutputIterator>
+    inline _OutputIterator
+    __copy(_RandomAccessIterator __first, _RandomAccessIterator __last,
+	   _OutputIterator __result, random_access_iterator_tag)
     {
-      typedef typename iterator_traits<_RandomAccessIter>::difference_type
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
           _Distance;
       for (_Distance __n = __last - __first; __n > 0; --__n) 
 	{
@@ -244,16 +244,16 @@ namespace std
       return __result + (__last - __first);
     }
 
-  template<typename _InputIter, typename _OutputIter>
-    inline _OutputIter
-    __copy_aux2(_InputIter __first, _InputIter __last, _OutputIter __result, 
-		__false_type)
+  template<typename _InputIterator, typename _OutputIterator>
+    inline _OutputIterator
+    __copy_aux2(_InputIterator __first, _InputIterator __last,
+		_OutputIterator __result, __false_type)
     { return __copy(__first, __last, __result, __iterator_category(__first)); }
 
-  template<typename _InputIter, typename _OutputIter>
-    inline _OutputIter
-    __copy_aux2(_InputIter __first, _InputIter __last, _OutputIter __result, 
-		__true_type)
+  template<typename _InputIterator, typename _OutputIterator>
+    inline _OutputIterator
+    __copy_aux2(_InputIterator __first, _InputIterator __last,
+		_OutputIterator __result, __true_type)
     { return __copy(__first, __last, __result, __iterator_category(__first)); }
 
   template<typename _Tp>
@@ -267,45 +267,45 @@ namespace std
 		__true_type)
     { return __copy_trivial(__first, __last, __result); }
 
-  template<typename _InputIter, typename _OutputIter>
-    inline _OutputIter
-    __copy_ni2(_InputIter __first, _InputIter __last, _OutputIter __result, 
-	       __true_type)
+  template<typename _InputIterator, typename _OutputIterator>
+    inline _OutputIterator
+    __copy_ni2(_InputIterator __first, _InputIterator __last,
+	       _OutputIterator __result, __true_type)
     {
-      typedef typename iterator_traits<_InputIter>::value_type
+      typedef typename iterator_traits<_InputIterator>::value_type
 	  _ValueType;
       typedef typename __type_traits<_ValueType>::has_trivial_assignment_operator
 	  _Trivial;
-      return _OutputIter(__copy_aux2(__first, __last, __result.base(), 
-				     _Trivial()));
+      return _OutputIterator(__copy_aux2(__first, __last, __result.base(),
+					 _Trivial()));
     }
 
-  template<typename _InputIter, typename _OutputIter>
-    inline _OutputIter
-    __copy_ni2(_InputIter __first, _InputIter __last, _OutputIter __result, 
-	       __false_type)
+  template<typename _InputIterator, typename _OutputIterator>
+    inline _OutputIterator
+    __copy_ni2(_InputIterator __first, _InputIterator __last,
+	       _OutputIterator __result, __false_type)
     {
-      typedef typename iterator_traits<_InputIter>::value_type _ValueType;
+      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
       typedef typename __type_traits<_ValueType>::has_trivial_assignment_operator
           _Trivial;
       return __copy_aux2(__first, __last, __result, _Trivial());
     }
 
-  template<typename _InputIter, typename _OutputIter>
-    inline _OutputIter
-    __copy_ni1(_InputIter __first, _InputIter __last, _OutputIter __result, 
-	       __true_type)
+  template<typename _InputIterator, typename _OutputIterator>
+    inline _OutputIterator
+    __copy_ni1(_InputIterator __first, _InputIterator __last,
+	       _OutputIterator __result, __true_type)
     {
-      typedef typename _Is_normal_iterator<_OutputIter>::_Normal __Normal;
+      typedef typename _Is_normal_iterator<_OutputIterator>::_Normal __Normal;
       return __copy_ni2(__first.base(), __last.base(), __result, __Normal());
     }
 
-  template<typename _InputIter, typename _OutputIter>
-    inline _OutputIter
-    __copy_ni1(_InputIter __first, _InputIter __last, _OutputIter __result, 
-	       __false_type)
+  template<typename _InputIterator, typename _OutputIterator>
+    inline _OutputIterator
+    __copy_ni1(_InputIterator __first, _InputIterator __last,
+	       _OutputIterator __result, __false_type)
     {
-      typedef typename _Is_normal_iterator<_OutputIter>::_Normal __Normal;
+      typedef typename _Is_normal_iterator<_OutputIterator>::_Normal __Normal;
       return __copy_ni2(__first, __last, __result, __Normal());
     }
 
@@ -322,35 +322,35 @@ namespace std
    *  optimizations such as unrolling).  If the input range and the output
    *  range overlap, then the copy_backward function should be used instead.
   */
-  template<typename _InputIter, typename _OutputIter>
-    inline _OutputIter
-    copy(_InputIter __first, _InputIter __last, _OutputIter __result)
+  template<typename _InputIterator, typename _OutputIterator>
+    inline _OutputIterator
+    copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-	    typename iterator_traits<_InputIter>::value_type>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator>::value_type>)
 
-       typedef typename _Is_normal_iterator<_InputIter>::_Normal __Normal;
+       typedef typename _Is_normal_iterator<_InputIterator>::_Normal __Normal;
        return __copy_ni1(__first, __last, __result, __Normal());
     }
 
-  template<typename _BidirectionalIter1, typename _BidirectionalIter2>
-    inline _BidirectionalIter2
-    __copy_backward(_BidirectionalIter1 __first, _BidirectionalIter1 __last, 
-		    _BidirectionalIter2 __result, bidirectional_iterator_tag)
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
+    inline _BidirectionalIterator2
+    __copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, 
+		    _BidirectionalIterator2 __result, bidirectional_iterator_tag)
     {
       while (__first != __last)
         *--__result = *--__last;
       return __result;
     }
 
-  template<typename _RandomAccessIter, typename _BidirectionalIter>
-    inline _BidirectionalIter
-    __copy_backward(_RandomAccessIter __first, _RandomAccessIter __last, 
-		    _BidirectionalIter __result, random_access_iterator_tag)
+  template<typename _RandomAccessIterator, typename _BidirectionalIterator>
+    inline _BidirectionalIterator
+    __copy_backward(_RandomAccessIterator __first, _RandomAccessIterator __last, 
+		    _BidirectionalIterator __result, random_access_iterator_tag)
     {
-      typename iterator_traits<_RandomAccessIter>::difference_type __n;
+      typename iterator_traits<_RandomAccessIterator>::difference_type __n;
       for (__n = __last - __first; __n > 0; --__n)
         *--__result = *--__last;
       return __result;
@@ -361,13 +361,13 @@ namespace std
   // have partial ordering of function templates.  All we're doing is
   // creating a specialization so that we can turn a call to copy_backward
   // into a memmove whenever possible.
-  template<typename _BidirectionalIter1, typename _BidirectionalIter2,
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
            typename _BoolType>
     struct __copy_backward_dispatch
     {
-      static _BidirectionalIter2
-      copy(_BidirectionalIter1 __first, _BidirectionalIter1 __last, 
-	   _BidirectionalIter2 __result)
+      static _BidirectionalIterator2
+      copy(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, 
+	   _BidirectionalIterator2 __result)
       {
         return __copy_backward(__first, __last, __result, 
 			       __iterator_category(__first));
@@ -483,12 +483,12 @@ namespace std
    *  types filling contiguous areas of memory, this becomes an inline call to
    *  @c memset.
   */
-  template<typename _ForwardIter, typename _Tp>
+  template<typename _ForwardIterator, typename _Tp>
     void
-    fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __value)
+    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
     {
       // concept requirements
-      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
 
       for ( ; __first != __last; ++__first)
 	*__first = __value;
@@ -505,12 +505,12 @@ namespace std
    *  types filling contiguous areas of memory, this becomes an inline call to
    *  @c memset.
   */
-  template<typename _OutputIter, typename _Size, typename _Tp>
-    _OutputIter
-    fill_n(_OutputIter __first, _Size __n, const _Tp& __value)
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+    _OutputIterator
+    fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
     {
       // concept requirements
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,_Tp>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,_Tp>)
 
       for ( ; __n > 0; --__n, ++__first)
 	*__first = __value;
@@ -576,24 +576,25 @@ namespace std
    *  second iterator points into the second range, and the elements pointed
    *  to by the iterators are not equal.
   */
-  template<typename _InputIter1, typename _InputIter2>
-    pair<_InputIter1, _InputIter2>
-    mismatch(_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2)
+  template<typename _InputIterator1, typename _InputIterator2>
+    pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+	     _InputIterator2 __first2)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
       __glibcpp_function_requires(_EqualityComparableConcept<
-	    typename iterator_traits<_InputIter1>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type>)
       __glibcpp_function_requires(_EqualityComparableConcept<
-	    typename iterator_traits<_InputIter2>::value_type>)
+	    typename iterator_traits<_InputIterator2>::value_type>)
 
-      while (__first1 != __last1 && *__first1 == *__first2) 
-	{
+      while (__first1 != __last1 && *__first1 == *__first2)
+        {
 	  ++__first1;
 	  ++__first2;
-	}
-      return pair<_InputIter1, _InputIter2>(__first1, __first2);
+        }
+      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
     }
 
   /**
@@ -610,21 +611,21 @@ namespace std
    *  second iterator points into the second range, and the elements pointed
    *  to by the iterators are not equal.
   */
-  template<typename _InputIter1, typename _InputIter2, typename _BinaryPredicate>
-    pair<_InputIter1, _InputIter2>
-    mismatch(_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2,
-	     _BinaryPredicate __binary_pred)
+  template<typename _InputIterator1, typename _InputIterator2, typename _BinaryPredicate>
+    pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+	     _InputIterator2 __first2, _BinaryPredicate __binary_pred)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
 
-      while (__first1 != __last1 && __binary_pred(*__first1, *__first2)) 
-	{
+      while (__first1 != __last1 && __binary_pred(*__first1, *__first2))
+        {
 	  ++__first1;
 	  ++__first2;
-	}
-      return pair<_InputIter1, _InputIter2>(__first1, __first2);
+        }
+      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
     }
 
   /**
@@ -638,16 +639,16 @@ namespace std
    *  false depending on whether all of the corresponding elements of the
    *  ranges are equal.
   */
-  template<typename _InputIter1, typename _InputIter2>
+  template<typename _InputIterator1, typename _InputIterator2>
     inline bool
-    equal(_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2)
+    equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
       __glibcpp_function_requires(_EqualOpConcept<
-	    typename iterator_traits<_InputIter1>::value_type,
-	    typename iterator_traits<_InputIter2>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
 
       for ( ; __first1 != __last1; ++__first1, ++__first2)
 	if (!(*__first1 == *__first2))
@@ -668,15 +669,15 @@ namespace std
    *  false depending on whether all of the corresponding elements of the
    *  ranges are equal.
   */
-  template<typename _InputIter1, typename _InputIter2, typename _BinaryPredicate>
+  template<typename _InputIterator1, typename _InputIterator2, typename _BinaryPredicate>
     inline bool
-    equal(_InputIter1 __first1, _InputIter1 __last1,
-	  _InputIter2 __first2,
+    equal(_InputIterator1 __first1, _InputIterator1 __last1,
+	  _InputIterator2 __first2,
 	  _BinaryPredicate __binary_pred)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
 
       for ( ; __first1 != __last1; ++__first1, ++__first2)
 	if (!__binary_pred(*__first1, *__first2))
@@ -698,18 +699,18 @@ namespace std
    *  (Quoted from [25.3.8]/1.)  If the iterators are all character pointers,
    *  then this is an inline call to @c memcmp.
   */
-  template<typename _InputIter1, typename _InputIter2>
+  template<typename _InputIterator1, typename _InputIterator2>
     bool
-    lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
-			    _InputIter2 __first2, _InputIter2 __last2)
+    lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
+			    _InputIterator2 __first2, _InputIterator2 __last2)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
       __glibcpp_function_requires(_LessThanComparableConcept<
-	    typename iterator_traits<_InputIter1>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type>)
       __glibcpp_function_requires(_LessThanComparableConcept<
-	    typename iterator_traits<_InputIter2>::value_type>)
+	    typename iterator_traits<_InputIterator2>::value_type>)
 
       for (;__first1 != __last1 && __first2 != __last2; ++__first1, ++__first2) 
 	{
@@ -733,15 +734,15 @@ namespace std
    *  The same as the four-parameter @c lexigraphical_compare, but uses the
    *  comp parameter instead of @c <.
   */
-  template<typename _InputIter1, typename _InputIter2, typename _Compare>
+  template<typename _InputIterator1, typename _InputIterator2, typename _Compare>
     bool
-    lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
-			    _InputIter2 __first2, _InputIter2 __last2,
+    lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
+			    _InputIterator2 __first2, _InputIterator2 __last2,
 			    _Compare __comp)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
 
       for ( ; __first1 != __last1 && __first2 != __last2
 	    ; ++__first1, ++__first2) 
diff --git a/libstdc++-v3/include/bits/stl_bvector.h b/libstdc++-v3/include/bits/stl_bvector.h
index f1c16cb3d5a..1a862b99d72 100644
--- a/libstdc++-v3/include/bits/stl_bvector.h
+++ b/libstdc++-v3/include/bits/stl_bvector.h
@@ -575,8 +575,8 @@ template <typename _Alloc>
     void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
       { _M_fill_assign((size_t) __n, (bool) __val); }
   
-    template <class _InputIter>
-    void _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type)
+    template <class _InputIterator>
+    void _M_assign_dispatch(_InputIterator __first, _InputIterator __last, __false_type)
       { _M_assign_aux(__first, __last, __iterator_category(__first)); }
   
     template <class _InputIterator>
diff --git a/libstdc++-v3/include/bits/stl_deque.h b/libstdc++-v3/include/bits/stl_deque.h
index 5cef4ded120..8805b7589f6 100644
--- a/libstdc++-v3/include/bits/stl_deque.h
+++ b/libstdc++-v3/include/bits/stl_deque.h
@@ -1112,7 +1112,7 @@ namespace std
   
     /**
      *  @brief  Inserts a range into the %deque.
-     *  @param  pos  An iterator into the %deque.
+     *  @param  position  An iterator into the %deque.
      *  @param  first  An input iterator.
      *  @param  last   An input iterator.
      *
@@ -1122,11 +1122,11 @@ namespace std
     */
     template<typename _InputIterator>
       void
-      insert(iterator __pos, _InputIterator __first, _InputIterator __last)
+      insert(iterator __position, _InputIterator __first, _InputIterator __last)
       {
         // Check whether it's an integral type.  If so, it's not an iterator.
         typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
-        _M_insert_dispatch(__pos, __first, __last, _Integral());
+        _M_insert_dispatch(__position, __first, __last, _Integral());
       }
   
     /**
@@ -1203,12 +1203,12 @@ namespace std
       }
   
     // called by the range constructor to implement [23.1.1]/9
-    template<typename _InputIter>
+    template<typename _InputIterator>
       void
-      _M_initialize_dispatch(_InputIter __first, _InputIter __last,
+      _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
                              __false_type)
       {
-        typedef typename iterator_traits<_InputIter>::iterator_category
+        typedef typename iterator_traits<_InputIterator>::iterator_category
                          _IterCategory;
         _M_range_initialize(__first, __last, _IterCategory());
       }
@@ -1268,11 +1268,11 @@ namespace std
       }
   
     // called by the range assign to implement [23.1.1]/9
-    template<typename _InputIter>
+    template<typename _InputIterator>
       void
-      _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type)
+      _M_assign_dispatch(_InputIterator __first, _InputIterator __last, __false_type)
       {
-        typedef typename iterator_traits<_InputIter>::iterator_category
+        typedef typename iterator_traits<_InputIterator>::iterator_category
                          _IterCategory;
         _M_assign_aux(__first, __last, _IterCategory());
       }
diff --git a/libstdc++-v3/include/bits/stl_iterator_base_funcs.h b/libstdc++-v3/include/bits/stl_iterator_base_funcs.h
index 7c245d056c6..8ea22a0a7e5 100644
--- a/libstdc++-v3/include/bits/stl_iterator_base_funcs.h
+++ b/libstdc++-v3/include/bits/stl_iterator_base_funcs.h
@@ -114,12 +114,12 @@ namespace std
       return __distance(__first, __last, __iterator_category(__first));
     }
   
-  template<typename _InputIter, typename _Distance>
+  template<typename _InputIterator, typename _Distance>
     inline void
-    __advance(_InputIter& __i, _Distance __n, input_iterator_tag)
+    __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
       while (__n--) ++__i;
     }
   
diff --git a/libstdc++-v3/include/bits/stl_list.h b/libstdc++-v3/include/bits/stl_list.h
index b8a59e106c7..46d9e7b6bda 100644
--- a/libstdc++-v3/include/bits/stl_list.h
+++ b/libstdc++-v3/include/bits/stl_list.h
@@ -773,12 +773,12 @@ namespace std
      *  time, and does not invalidate iterators and references.
     */
     void
-    insert(iterator __pos, size_type __n, const value_type& __x)
-    { _M_fill_insert(__pos, __n, __x); }
+    insert(iterator __position, size_type __n, const value_type& __x)
+    { _M_fill_insert(__position, __n, __x); }
   
     /**
      *  @brief  Inserts a range into the %list.
-     *  @param  pos  An iterator into the %list.
+     *  @param  position  An iterator into the %list.
      *  @param  first  An input iterator.
      *  @param  last   An input iterator.
      *
@@ -790,11 +790,11 @@ namespace std
     */
     template<typename _InputIterator>
       void
-      insert(iterator __pos, _InputIterator __first, _InputIterator __last)
+      insert(iterator __position, _InputIterator __first, _InputIterator __last)
       {
         // Check whether it's an integral type.  If so, it's not an iterator.
         typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
-        _M_insert_dispatch(__pos, __first, __last, _Integral());
+        _M_insert_dispatch(__position, __first, __last, _Integral());
       }
   
     /**
@@ -968,9 +968,9 @@ namespace std
       }
   
     // called by the range assign to implement [23.1.1]/9
-    template<typename _InputIter>
+    template<typename _InputIterator>
       void
-      _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type);
+      _M_assign_dispatch(_InputIterator __first, _InputIterator __last, __false_type);
   
     // Called by assign(n,t), and the range assign when it turns out to be the
     // same thing.
diff --git a/libstdc++-v3/include/bits/stl_multiset.h b/libstdc++-v3/include/bits/stl_multiset.h
index 2791a2f2f34..9235f8fd5dc 100644
--- a/libstdc++-v3/include/bits/stl_multiset.h
+++ b/libstdc++-v3/include/bits/stl_multiset.h
@@ -271,7 +271,3 @@ inline void swap(multiset<_Key,_Compare,_Alloc>& __x,
 } // namespace std
 
 #endif /* __GLIBCPP_INTERNAL_MULTISET_H */
-
-// Local Variables:
-// mode:C++
-// End:
diff --git a/libstdc++-v3/include/bits/stl_numeric.h b/libstdc++-v3/include/bits/stl_numeric.h
index 23f2bcc4512..53b193b95ce 100644
--- a/libstdc++-v3/include/bits/stl_numeric.h
+++ b/libstdc++-v3/include/bits/stl_numeric.h
@@ -209,7 +209,3 @@ namespace std
 } // namespace std
 
 #endif /* _CPP_BITS_STL_NUMERIC_H */
-
-// Local Variables:
-// mode:C++
-// End:
diff --git a/libstdc++-v3/include/bits/stl_relops.h b/libstdc++-v3/include/bits/stl_relops.h
index ce3dc0b9b39..a8a3a173dd4 100644
--- a/libstdc++-v3/include/bits/stl_relops.h
+++ b/libstdc++-v3/include/bits/stl_relops.h
@@ -135,7 +135,3 @@ inline bool operator>=(const _Tp& __x, const _Tp& __y) {
 } // namespace std
 
 #endif /* _CPP_BITS_STL_RELOPS_H */
-
-// Local Variables:
-// mode:C++
-// End:
diff --git a/libstdc++-v3/include/bits/stl_set.h b/libstdc++-v3/include/bits/stl_set.h
index b6f70e8bbeb..96dc4b307a3 100644
--- a/libstdc++-v3/include/bits/stl_set.h
+++ b/libstdc++-v3/include/bits/stl_set.h
@@ -268,7 +268,3 @@ inline void swap(set<_Key,_Compare,_Alloc>& __x,
 } // namespace std
 
 #endif /* __GLIBCPP_INTERNAL_SET_H */
-
-// Local Variables:
-// mode:C++
-// End:
diff --git a/libstdc++-v3/include/bits/stl_threads.h b/libstdc++-v3/include/bits/stl_threads.h
index 53baf256184..a95fc38a423 100644
--- a/libstdc++-v3/include/bits/stl_threads.h
+++ b/libstdc++-v3/include/bits/stl_threads.h
@@ -208,7 +208,7 @@ namespace std
   private:
     void operator=(const _STL_auto_lock&);
     _STL_auto_lock(const _STL_auto_lock&);
-  };
+  } __attribute__ ((__unused__));
   
 } // namespace std
 
diff --git a/libstdc++-v3/include/bits/stl_uninitialized.h b/libstdc++-v3/include/bits/stl_uninitialized.h
index b5f7b8c40b6..5f860580433 100644
--- a/libstdc++-v3/include/bits/stl_uninitialized.h
+++ b/libstdc++-v3/include/bits/stl_uninitialized.h
@@ -68,20 +68,20 @@ namespace std
 
   // uninitialized_copy
 
-  template<typename _InputIter, typename _ForwardIter>
-    inline _ForwardIter 
-    __uninitialized_copy_aux(_InputIter __first, _InputIter __last,
-			     _ForwardIter __result,
+  template<typename _InputIterator, typename _ForwardIterator>
+    inline _ForwardIterator 
+    __uninitialized_copy_aux(_InputIterator __first, _InputIterator __last,
+			     _ForwardIterator __result,
 			     __true_type)
     { return copy(__first, __last, __result); }
 
-  template<typename _InputIter, typename _ForwardIter>
-    _ForwardIter 
-    __uninitialized_copy_aux(_InputIter __first, _InputIter __last,
-			     _ForwardIter __result,
+  template<typename _InputIterator, typename _ForwardIterator>
+    _ForwardIterator 
+    __uninitialized_copy_aux(_InputIterator __first, _InputIterator __last,
+			     _ForwardIterator __result,
 			     __false_type)
     {
-      _ForwardIter __cur = __result;
+      _ForwardIterator __cur = __result;
       try {
 	for ( ; __first != __last; ++__first, ++__cur)
 	  _Construct(&*__cur, *__first);
@@ -103,11 +103,11 @@ namespace std
    *
    *  Like copy(), but does not require an initialized output range.
   */
-  template<typename _InputIter, typename _ForwardIter>
-    inline _ForwardIter
-    uninitialized_copy(_InputIter __first, _InputIter __last, _ForwardIter __result)
+  template<typename _InputIterator, typename _ForwardIterator>
+    inline _ForwardIterator
+    uninitialized_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result)
     {
-      typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
       typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
       return __uninitialized_copy_aux(__first, __last, __result, _Is_POD());
     }
@@ -129,18 +129,18 @@ namespace std
 
   // Valid if copy construction is equivalent to assignment, and if the
   // destructor is trivial.
-  template<typename _ForwardIter, typename _Tp>
+  template<typename _ForwardIterator, typename _Tp>
     inline void
-    __uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last, 
+    __uninitialized_fill_aux(_ForwardIterator __first, _ForwardIterator __last, 
 			     const _Tp& __x, __true_type)
     { fill(__first, __last, __x); }
 
-  template<typename _ForwardIter, typename _Tp>
+  template<typename _ForwardIterator, typename _Tp>
     void
-    __uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last, 
+    __uninitialized_fill_aux(_ForwardIterator __first, _ForwardIterator __last, 
 			     const _Tp& __x, __false_type)
     {
-      _ForwardIter __cur = __first;
+      _ForwardIterator __cur = __first;
       try {
 	for ( ; __cur != __last; ++__cur)
 	  _Construct(&*__cur, __x);
@@ -161,31 +161,31 @@ namespace std
    *
    *  Like fill(), but does not require an initialized output range.
   */
-  template<typename _ForwardIter, typename _Tp>
+  template<typename _ForwardIterator, typename _Tp>
     inline void
-    uninitialized_fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __x)
+    uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x)
     {
-      typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
       typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
       __uninitialized_fill_aux(__first, __last, __x, _Is_POD());
     }
 
   // Valid if copy construction is equivalent to assignment, and if the
   //  destructor is trivial.
-  template<typename _ForwardIter, typename _Size, typename _Tp>
-    inline _ForwardIter
-    __uninitialized_fill_n_aux(_ForwardIter __first, _Size __n,
+  template<typename _ForwardIterator, typename _Size, typename _Tp>
+    inline _ForwardIterator
+    __uninitialized_fill_n_aux(_ForwardIterator __first, _Size __n,
 			       const _Tp& __x, __true_type)
     {
       return fill_n(__first, __n, __x);
     }
 
-  template<typename _ForwardIter, typename _Size, typename _Tp>
-    _ForwardIter
-    __uninitialized_fill_n_aux(_ForwardIter __first, _Size __n,
+  template<typename _ForwardIterator, typename _Size, typename _Tp>
+    _ForwardIterator
+    __uninitialized_fill_n_aux(_ForwardIterator __first, _Size __n,
 			       const _Tp& __x, __false_type)
     {
-      _ForwardIter __cur = __first;
+      _ForwardIterator __cur = __first;
       try {
 	for ( ; __n > 0; --__n, ++__cur)
 	  _Construct(&*__cur, __x);
@@ -207,11 +207,11 @@ namespace std
    *
    *  Like fill_n(), but does not require an initialized output range.
   */
-  template<typename _ForwardIter, typename _Size, typename _Tp>
-    inline _ForwardIter 
-    uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x)
+  template<typename _ForwardIterator, typename _Size, typename _Tp>
+    inline _ForwardIterator 
+    uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
     {
-      typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
       typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
       return __uninitialized_fill_n_aux(__first, __n, __x, _Is_POD());
     }
@@ -224,13 +224,13 @@ namespace std
   //  copies [first2, last2) into
   //  [result, result + (last1 - first1) + (last2 - first2)).
 
-  template<typename _InputIter1, typename _InputIter2, typename _ForwardIter>
-    inline _ForwardIter
-    __uninitialized_copy_copy(_InputIter1 __first1, _InputIter1 __last1,
-			      _InputIter2 __first2, _InputIter2 __last2,
-			      _ForwardIter __result)
+  template<typename _InputIterator1, typename _InputIterator2, typename _ForwardIterator>
+    inline _ForwardIterator
+    __uninitialized_copy_copy(_InputIterator1 __first1, _InputIterator1 __last1,
+			      _InputIterator2 __first2, _InputIterator2 __last2,
+			      _ForwardIterator __result)
     {
-      _ForwardIter __mid = uninitialized_copy(__first1, __last1, __result);
+      _ForwardIterator __mid = uninitialized_copy(__first1, __last1, __result);
       try {
 	return uninitialized_copy(__first2, __last2, __mid);
       }
@@ -244,11 +244,11 @@ namespace std
   // __uninitialized_fill_copy
   // Fills [result, mid) with x, and copies [first, last) into
   //  [mid, mid + (last - first)).
-  template<typename _ForwardIter, typename _Tp, typename _InputIter>
-    inline _ForwardIter 
-    __uninitialized_fill_copy(_ForwardIter __result, _ForwardIter __mid,
+  template<typename _ForwardIterator, typename _Tp, typename _InputIterator>
+    inline _ForwardIterator 
+    __uninitialized_fill_copy(_ForwardIterator __result, _ForwardIterator __mid,
 			      const _Tp& __x,
-			      _InputIter __first, _InputIter __last)
+			      _InputIterator __first, _InputIterator __last)
     {
       uninitialized_fill(__result, __mid, __x);
       try {
@@ -264,13 +264,13 @@ namespace std
   // __uninitialized_copy_fill
   // Copies [first1, last1) into [first2, first2 + (last1 - first1)), and
   //  fills [first2 + (last1 - first1), last2) with x.
-  template<typename _InputIter, typename _ForwardIter, typename _Tp>
+  template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
     inline void
-    __uninitialized_copy_fill(_InputIter __first1, _InputIter __last1,
-			      _ForwardIter __first2, _ForwardIter __last2,
+    __uninitialized_copy_fill(_InputIterator __first1, _InputIterator __last1,
+			      _ForwardIterator __first2, _ForwardIterator __last2,
 			      const _Tp& __x)
     {
-      _ForwardIter __mid2 = uninitialized_copy(__first1, __last1, __first2);
+      _ForwardIterator __mid2 = uninitialized_copy(__first1, __last1, __first2);
       try {
 	uninitialized_fill(__mid2, __last2, __x);
       }
@@ -284,7 +284,3 @@ namespace std
 } // namespace std
 
 #endif /* _CPP_BITS_STL_UNINITIALIZED_H */
-
-// Local Variables:
-// mode:C++
-// End:
diff --git a/libstdc++-v3/include/bits/stl_vector.h b/libstdc++-v3/include/bits/stl_vector.h
index c90a476a758..bbd2edb8bb6 100644
--- a/libstdc++-v3/include/bits/stl_vector.h
+++ b/libstdc++-v3/include/bits/stl_vector.h
@@ -650,12 +650,12 @@ namespace std
        *  consider using std::list.
        */
       void
-      insert(iterator __pos, size_type __n, const value_type& __x)
-      { _M_fill_insert(__pos, __n, __x); }
+      insert(iterator __position, size_type __n, const value_type& __x)
+      { _M_fill_insert(__position, __n, __x); }
       
       /**
        *  @brief  Inserts a range into the %vector.
-       *  @param  pos  An iterator into the %vector.
+       *  @param  position  An iterator into the %vector.
        *  @param  first  An input iterator.
        *  @param  last   An input iterator.
        *
@@ -669,11 +669,11 @@ namespace std
        */
       template<typename _InputIterator>
         void
-        insert(iterator __pos, _InputIterator __first, _InputIterator __last)
+        insert(iterator __position, _InputIterator __first, _InputIterator __last)
         {
 	  // Check whether it's an integral type.  If so, it's not an iterator.
 	  typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
-	  _M_insert_dispatch(__pos, __first, __last, _Integral());
+	  _M_insert_dispatch(__position, __first, __last, _Integral());
 	}
       
       /**
@@ -780,12 +780,12 @@ namespace std
 	}
       
       // Called by the range constructor to implement [23.1.1]/9
-      template<typename _InputIter>
+      template<typename _InputIterator>
         void
-        _M_initialize_dispatch(_InputIter __first, _InputIter __last,
+        _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
 			       __false_type)
         {
-	  typedef typename iterator_traits<_InputIter>::iterator_category
+	  typedef typename iterator_traits<_InputIterator>::iterator_category
 	    _IterCategory;
 	  _M_range_initialize(__first, __last, _IterCategory());
 	}
@@ -827,11 +827,11 @@ namespace std
 	}
       
       // Called by the range assign to implement [23.1.1]/9
-      template<typename _InputIter>
+      template<typename _InputIterator>
         void
-        _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type)
+        _M_assign_dispatch(_InputIterator __first, _InputIterator __last, __false_type)
         {
-	  typedef typename iterator_traits<_InputIter>::iterator_category
+	  typedef typename iterator_traits<_InputIterator>::iterator_category
 	    _IterCategory;
 	  _M_assign_aux(__first, __last, _IterCategory());
 	}
diff --git a/libstdc++-v3/include/bits/vector.tcc b/libstdc++-v3/include/bits/vector.tcc
index 0b6724c9147..a3a36c555cc 100644
--- a/libstdc++-v3/include/bits/vector.tcc
+++ b/libstdc++-v3/include/bits/vector.tcc
@@ -176,10 +176,10 @@ namespace std
         erase(fill_n(begin(), __n, __val), end());
     }
   
-  template<typename _Tp, typename _Alloc> template<typename _InputIter>
+  template<typename _Tp, typename _Alloc> template<typename _InputIterator>
     void
     vector<_Tp,_Alloc>::
-    _M_assign_aux(_InputIter __first, _InputIter __last, input_iterator_tag)
+    _M_assign_aux(_InputIterator __first, _InputIterator __last, input_iterator_tag)
     {
       iterator __cur(begin());
       for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
@@ -190,10 +190,10 @@ namespace std
         insert(end(), __first, __last);
     }
   
-  template<typename _Tp, typename _Alloc> template<typename _ForwardIter>
+  template<typename _Tp, typename _Alloc> template<typename _ForwardIterator>
     void
     vector<_Tp,_Alloc>::
-    _M_assign_aux(_ForwardIter __first, _ForwardIter __last,
+    _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
                   forward_iterator_tag)
     {
       size_type __len = std::distance(__first, __last);
@@ -215,7 +215,7 @@ namespace std
       }
       else
       {
-        _ForwardIter __mid = __first;
+        _ForwardIterator __mid = __first;
         advance(__mid, size());
         copy(__first, __mid, this->_M_start);
         this->_M_finish = uninitialized_copy(__mid, __last, this->_M_finish);
diff --git a/libstdc++-v3/include/ext/algorithm b/libstdc++-v3/include/ext/algorithm
index b35d36f5e42..2d457503393 100644
--- a/libstdc++-v3/include/ext/algorithm
+++ b/libstdc++-v3/include/ext/algorithm
@@ -77,10 +77,10 @@ namespace __gnu_cxx
   //--------------------------------------------------
   // copy_n (not part of the C++ standard)
 
-  template<typename _InputIter, typename _Size, typename _OutputIter>
-    pair<_InputIter, _OutputIter>
-    __copy_n(_InputIter __first, _Size __count,
-	     _OutputIter __result,
+  template<typename _InputIterator, typename _Size, typename _OutputIterator>
+    pair<_InputIterator, _OutputIterator>
+    __copy_n(_InputIterator __first, _Size __count,
+	     _OutputIterator __result,
 	     input_iterator_tag)
     {
       for ( ; __count > 0; --__count) {
@@ -88,17 +88,17 @@ namespace __gnu_cxx
 	++__first;
 	++__result;
       }
-      return pair<_InputIter, _OutputIter>(__first, __result);
+      return pair<_InputIterator, _OutputIterator>(__first, __result);
     }
 
-  template<typename _RAIter, typename _Size, typename _OutputIter>
-    inline pair<_RAIter, _OutputIter>
-    __copy_n(_RAIter __first, _Size __count,
-	     _OutputIter __result,
+  template<typename _RAIterator, typename _Size, typename _OutputIterator>
+    inline pair<_RAIterator, _OutputIterator>
+    __copy_n(_RAIterator __first, _Size __count,
+	     _OutputIterator __result,
 	     random_access_iterator_tag)
     {
-      _RAIter __last = __first + __count;
-      return pair<_RAIter, _OutputIter>(__last,
+      _RAIterator __last = __first + __count;
+      return pair<_RAIterator, _OutputIterator>(__last,
 					std::copy(__first, __last, __result));
     }
 
@@ -116,23 +116,23 @@ namespace __gnu_cxx
    *  optimizations such as unrolling).
    *  @ingroup SGIextensions
   */
-  template<typename _InputIter, typename _Size, typename _OutputIter>
-    inline pair<_InputIter, _OutputIter>
-    copy_n(_InputIter __first, _Size __count, _OutputIter __result)
+  template<typename _InputIterator, typename _Size, typename _OutputIterator>
+    inline pair<_InputIterator, _OutputIterator>
+    copy_n(_InputIterator __first, _Size __count, _OutputIterator __result)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-	    typename iterator_traits<_InputIter>::value_type>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator>::value_type>)
 
       return __copy_n(__first, __count, __result,
 		      std::__iterator_category(__first));
     }
 
-  template<typename _InputIter1, typename _InputIter2>
+  template<typename _InputIterator1, typename _InputIterator2>
     int
-    __lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1,
-				   _InputIter2 __first2, _InputIter2 __last2)
+    __lexicographical_compare_3way(_InputIterator1 __first1, _InputIterator1 __last1,
+				   _InputIterator2 __first2, _InputIterator2 __last2)
     {
       while (__first1 != __last1 && __first2 != __last2) {
 	if (*__first1 < *__first2)
@@ -195,18 +195,18 @@ namespace __gnu_cxx
    *  This is an SGI extension.
    *  @ingroup SGIextensions
   */
-  template<typename _InputIter1, typename _InputIter2>
+  template<typename _InputIterator1, typename _InputIterator2>
     int
-    lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1,
-				 _InputIter2 __first2, _InputIter2 __last2)
+    lexicographical_compare_3way(_InputIterator1 __first1, _InputIterator1 __last1,
+				 _InputIterator2 __first2, _InputIterator2 __last2)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
       __glibcpp_function_requires(_LessThanComparableConcept<
-	    typename iterator_traits<_InputIter1>::value_type>)
+	    typename iterator_traits<_InputIterator1>::value_type>)
       __glibcpp_function_requires(_LessThanComparableConcept<
-	    typename iterator_traits<_InputIter2>::value_type>)
+	    typename iterator_traits<_InputIterator2>::value_type>)
 
       return __lexicographical_compare_3way(__first1, __last1, __first2, __last2);
     }
@@ -214,32 +214,32 @@ namespace __gnu_cxx
   // count and count_if: this version, whose return type is void, was present
   // in the HP STL, and is retained as an extension for backward compatibility.
 
-  template<typename _InputIter, typename _Tp, typename _Size>
+  template<typename _InputIterator, typename _Tp, typename _Size>
     void
-    count(_InputIter __first, _InputIter __last,
+    count(_InputIterator __first, _InputIterator __last,
 	  const _Tp& __value,
 	  _Size& __n)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
       __glibcpp_function_requires(_EqualityComparableConcept<
-	    typename iterator_traits<_InputIter>::value_type >)
+	    typename iterator_traits<_InputIterator>::value_type >)
       __glibcpp_function_requires(_EqualityComparableConcept<_Tp>)
       for ( ; __first != __last; ++__first)
 	if (*__first == __value)
 	  ++__n;
     }
 
-  template<typename _InputIter, typename _Predicate, typename _Size>
+  template<typename _InputIterator, typename _Predicate, typename _Size>
     void
-    count_if(_InputIter __first, _InputIter __last,
+    count_if(_InputIterator __first, _InputIterator __last,
 	     _Predicate __pred,
 	     _Size& __n)
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
       __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
-	    typename iterator_traits<_InputIter>::value_type>)
+	    typename iterator_traits<_InputIterator>::value_type>)
       for ( ; __first != __last; ++__first)
 	if (__pred(*__first))
 	  ++__n;
@@ -252,15 +252,15 @@ namespace __gnu_cxx
    *  @ingroup SGIextensions
    *  @doctodo
   */
-  template<typename _ForwardIter, typename _OutputIter, typename _Distance>
-    _OutputIter
-    random_sample_n(_ForwardIter __first, _ForwardIter __last,
-                    _OutputIter __out, const _Distance __n)
+  template<typename _ForwardIterator, typename _OutputIterator, typename _Distance>
+    _OutputIterator
+    random_sample_n(_ForwardIterator __first, _ForwardIterator __last,
+                    _OutputIterator __out, const _Distance __n)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-		typename iterator_traits<_ForwardIter>::value_type>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+		typename iterator_traits<_ForwardIterator>::value_type>)
 
       _Distance __remaining = std::distance(__first, __last);
       _Distance __m = min(__n, __remaining);
@@ -283,17 +283,17 @@ namespace __gnu_cxx
    *  @ingroup SGIextensions
    *  @doctodo
   */
-  template<typename _ForwardIter, typename _OutputIter, typename _Distance,
+  template<typename _ForwardIterator, typename _OutputIterator, typename _Distance,
 	   typename _RandomNumberGenerator>
-    _OutputIter
-    random_sample_n(_ForwardIter __first, _ForwardIter __last,
-                   _OutputIter __out, const _Distance __n, 
+    _OutputIterator
+    random_sample_n(_ForwardIterator __first, _ForwardIterator __last,
+                   _OutputIterator __out, const _Distance __n, 
 		   _RandomNumberGenerator& __rand)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
-      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
-		typename iterator_traits<_ForwardIter>::value_type>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+		typename iterator_traits<_ForwardIterator>::value_type>)
       __glibcpp_function_requires(_UnaryFunctionConcept<
 		_RandomNumberGenerator, _Distance, _Distance>)
 
@@ -313,10 +313,10 @@ namespace __gnu_cxx
       return __out;
     }
 
-  template<typename _InputIter, typename _RandomAccessIter, typename _Distance>
-    _RandomAccessIter
-    __random_sample(_InputIter __first, _InputIter __last,
-		    _RandomAccessIter __out,
+  template<typename _InputIterator, typename _RandomAccessIterator, typename _Distance>
+    _RandomAccessIterator
+    __random_sample(_InputIterator __first, _InputIterator __last,
+		    _RandomAccessIterator __out,
 		    const _Distance __n)
     {
       _Distance __m = 0;
@@ -335,11 +335,11 @@ namespace __gnu_cxx
       return __out + __m;
     }
 
-  template<typename _InputIter, typename _RandomAccessIter,
+  template<typename _InputIterator, typename _RandomAccessIterator,
 	   typename _RandomNumberGenerator, typename _Distance>
-    _RandomAccessIter
-    __random_sample(_InputIter __first, _InputIter __last,
-		    _RandomAccessIter __out,
+    _RandomAccessIterator
+    __random_sample(_InputIterator __first, _InputIterator __last,
+		    _RandomAccessIterator __out,
 		    _RandomNumberGenerator& __rand,
 		    const _Distance __n)
     {
@@ -368,15 +368,15 @@ namespace __gnu_cxx
    *  @ingroup SGIextensions
    *  @doctodo
   */
-  template<typename _InputIter, typename _RandomAccessIter>
-    inline _RandomAccessIter
-    random_sample(_InputIter __first, _InputIter __last,
-		  _RandomAccessIter __out_first, _RandomAccessIter __out_last) 
+  template<typename _InputIterator, typename _RandomAccessIterator>
+    inline _RandomAccessIterator
+    random_sample(_InputIterator __first, _InputIterator __last,
+		  _RandomAccessIterator __out_first, _RandomAccessIterator __out_last) 
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
       __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
-	    _RandomAccessIter>)
+	    _RandomAccessIterator>)
 
       return __random_sample(__first, __last,
 			     __out_first, __out_last - __out_first);
@@ -387,17 +387,17 @@ namespace __gnu_cxx
    *  @ingroup SGIextensions
    *  @doctodo
   */
-  template<typename _InputIter, typename _RandomAccessIter, 
+  template<typename _InputIterator, typename _RandomAccessIterator, 
 	   typename _RandomNumberGenerator>
-    inline _RandomAccessIter
-    random_sample(_InputIter __first, _InputIter __last,
-		  _RandomAccessIter __out_first, _RandomAccessIter __out_last,
+    inline _RandomAccessIterator
+    random_sample(_InputIterator __first, _InputIterator __last,
+		  _RandomAccessIterator __out_first, _RandomAccessIterator __out_last,
 		  _RandomNumberGenerator& __rand) 
     {
       // concept requirements
-      __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
+      __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
       __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
-	    _RandomAccessIter>)
+	    _RandomAccessIterator>)
 
       return __random_sample(__first, __last,
 			     __out_first, __rand,
@@ -408,9 +408,9 @@ namespace __gnu_cxx
   // a heap.  This function is an extension, not part of the C++
   // standard.
 
-  template<typename _RandomAccessIter, typename _Distance>
+  template<typename _RandomAccessIterator, typename _Distance>
     bool
-    __is_heap(_RandomAccessIter __first, _Distance __n)
+    __is_heap(_RandomAccessIterator __first, _Distance __n)
     {
       _Distance __parent = 0;
       for (_Distance __child = 1; __child < __n; ++__child) {
@@ -422,10 +422,10 @@ namespace __gnu_cxx
       return true;
     }
 
-  template<typename _RandomAccessIter, typename _Distance,
+  template<typename _RandomAccessIterator, typename _Distance,
            typename _StrictWeakOrdering>
     bool
-    __is_heap(_RandomAccessIter __first, _StrictWeakOrdering __comp,
+    __is_heap(_RandomAccessIterator __first, _StrictWeakOrdering __comp,
 	      _Distance __n)
     {
       _Distance __parent = 0;
@@ -443,14 +443,14 @@ namespace __gnu_cxx
    *  @ingroup SGIextensions
    *  @doctodo
   */
-  template<typename _RandomAccessIter>
+  template<typename _RandomAccessIterator>
     inline bool
-    is_heap(_RandomAccessIter __first, _RandomAccessIter __last)
+    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
     {
       // concept requirements
-      __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIter>)
+      __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>)
       __glibcpp_function_requires(_LessThanComparableConcept<
-	    typename iterator_traits<_RandomAccessIter>::value_type>)
+	    typename iterator_traits<_RandomAccessIterator>::value_type>)
 
       return __is_heap(__first, __last - __first);
     }
@@ -460,16 +460,16 @@ namespace __gnu_cxx
    *  @ingroup SGIextensions
    *  @doctodo
   */
-  template<typename _RandomAccessIter, typename _StrictWeakOrdering>
+  template<typename _RandomAccessIterator, typename _StrictWeakOrdering>
     inline bool
-    is_heap(_RandomAccessIter __first, _RandomAccessIter __last,
+    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
 	    _StrictWeakOrdering __comp)
     {
       // concept requirements
-      __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIter>)
+      __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_StrictWeakOrdering,
-	    typename iterator_traits<_RandomAccessIter>::value_type, 
-	    typename iterator_traits<_RandomAccessIter>::value_type>)
+	    typename iterator_traits<_RandomAccessIterator>::value_type, 
+	    typename iterator_traits<_RandomAccessIterator>::value_type>)
 
       return __is_heap(__first, __comp, __last - __first);
     }
@@ -483,19 +483,19 @@ namespace __gnu_cxx
    *  @ingroup SGIextensions
    *  @doctodo
   */
-  template<typename _ForwardIter>
+  template<typename _ForwardIterator>
     bool
-    is_sorted(_ForwardIter __first, _ForwardIter __last)
+    is_sorted(_ForwardIterator __first, _ForwardIterator __last)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_LessThanComparableConcept<
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_ForwardIterator>::value_type>)
 
       if (__first == __last)
 	return true;
 
-      _ForwardIter __next = __first;
+      _ForwardIterator __next = __first;
       for (++__next; __next != __last; __first = __next, ++__next) {
 	if (*__next < *__first)
 	  return false;
@@ -509,20 +509,20 @@ namespace __gnu_cxx
    *  @ingroup SGIextensions
    *  @doctodo
   */
-  template<typename _ForwardIter, typename _StrictWeakOrdering>
+  template<typename _ForwardIterator, typename _StrictWeakOrdering>
     bool
-    is_sorted(_ForwardIter __first, _ForwardIter __last, _StrictWeakOrdering __comp)
+    is_sorted(_ForwardIterator __first, _ForwardIterator __last, _StrictWeakOrdering __comp)
     {
       // concept requirements
-      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+      __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_StrictWeakOrdering,
-	    typename iterator_traits<_ForwardIter>::value_type, 
-	    typename iterator_traits<_ForwardIter>::value_type>)
+	    typename iterator_traits<_ForwardIterator>::value_type, 
+	    typename iterator_traits<_ForwardIterator>::value_type>)
 
       if (__first == __last)
 	return true;
 
-      _ForwardIter __next = __first;
+      _ForwardIterator __next = __first;
       for (++__next; __next != __last; __first = __next, ++__next) {
 	if (__comp(*__next, *__first))
 	  return false;
diff --git a/libstdc++-v3/include/ext/slist b/libstdc++-v3/include/ext/slist
index 9c2cce12473..780e2c2d693 100644
--- a/libstdc++-v3/include/ext/slist
+++ b/libstdc++-v3/include/ext/slist
@@ -474,10 +474,10 @@ private:
   }
 
   // Check whether it's an integral type.  If so, it's not an iterator.
-  template <class _InIter>
+  template <class _InIterator>
   void _M_insert_after_range(_Node_base* __pos, 
-                             _InIter __first, _InIter __last) {
-    typedef typename _Is_integer<_InIter>::_Integral _Integral;
+                             _InIterator __first, _InIterator __last) {
+    typedef typename _Is_integer<_InIterator>::_Integral _Integral;
     _M_insert_after_range(__pos, __first, __last, _Integral());
   }
 
@@ -487,9 +487,9 @@ private:
     _M_insert_after_fill(__pos, __n, __x);
   }
 
-  template <class _InIter>
+  template <class _InIterator>
   void _M_insert_after_range(_Node_base* __pos,
-                             _InIter __first, _InIter __last,
+                             _InIterator __first, _InIterator __last,
                              __false_type) {
     while (__first != __last) {
       __pos = __slist_make_link(__pos, _M_create_node(*__first));
@@ -513,8 +513,8 @@ public:
 
   // We don't need any dispatching tricks here, because _M_insert_after_range
   // already does them.
-  template <class _InIter>
-  void insert_after(iterator __pos, _InIter __first, _InIter __last) {
+  template <class _InIterator>
+  void insert_after(iterator __pos, _InIterator __first, _InIterator __last) {
     _M_insert_after_range(__pos._M_node, __first, __last);
   }
 
@@ -537,8 +537,8 @@ public:
     
   // We don't need any dispatching tricks here, because _M_insert_after_range
   // already does them.
-  template <class _InIter>
-  void insert(iterator __pos, _InIter __first, _InIter __last) {
+  template <class _InIterator>
+  void insert(iterator __pos, _InIterator __first, _InIterator __last) {
     _M_insert_after_range(__slist_previous(&this->_M_head, __pos._M_node), 
                           __first, __last);
   }
@@ -678,9 +678,9 @@ void slist<_Tp, _Alloc>::_M_fill_assign(size_type __n, const _Tp& __val) {
     this->_M_erase_after(__prev, 0);
 }
 
-template <class _Tp, class _Alloc> template <class _InputIter>
+template <class _Tp, class _Alloc> template <class _InputIterator>
 void
-slist<_Tp, _Alloc>::_M_assign_dispatch(_InputIter __first, _InputIter __last,
+slist<_Tp, _Alloc>::_M_assign_dispatch(_InputIterator __first, _InputIterator __last,
                                        __false_type)
 {
   _Node_base* __prev = &this->_M_head;
diff --git a/libstdc++-v3/include/std/std_bitset.h b/libstdc++-v3/include/std/std_bitset.h
index e2e2cc5625e..558389207c1 100644
--- a/libstdc++-v3/include/std/std_bitset.h
+++ b/libstdc++-v3/include/std/std_bitset.h
@@ -698,7 +698,7 @@ namespace std
     /**
      *  @brief  Use a subset of a string.
      *  @param  s  A string of '0' and '1' characters.
-     *  @param  pos  Index of the first character in @a s to use; defaults
+     *  @param  position  Index of the first character in @a s to use; defaults
      *               to zero.
      *  @throw  std::out_of_range  If @a pos is bigger the size of @a s.
      *  @throw  std::invalid_argument  If a character appears in the string
@@ -706,18 +706,18 @@ namespace std
     */
     template<class _CharT, class _Traits, class _Alloc>
       explicit bitset(const basic_string<_CharT, _Traits, _Alloc>& __s,
-		      size_t __pos = 0) : _Base()
+		      size_t __position = 0) : _Base()
       {
-	if (__pos > __s.size())
+	if (__position > __s.size())
 	  __throw_out_of_range("bitset::bitset initial position not valid");
-	_M_copy_from_string(__s, __pos,
+	_M_copy_from_string(__s, __position,
 			    basic_string<_CharT, _Traits, _Alloc>::npos);
       }
 
     /**
      *  @brief  Use a subset of a string.
      *  @param  s  A string of '0' and '1' characters.
-     *  @param  pos  Index of the first character in @a s to use.
+     *  @param  position  Index of the first character in @a s to use.
      *  @param  n    The number of characters to copy.
      *  @throw  std::out_of_range  If @a pos is bigger the size of @a s.
      *  @throw  std::invalid_argument  If a character appears in the string
@@ -725,11 +725,11 @@ namespace std
     */
     template<class _CharT, class _Traits, class _Alloc>
       bitset(const basic_string<_CharT, _Traits, _Alloc>& __s,
-	     size_t __pos, size_t __n) : _Base()
+	     size_t __position, size_t __n) : _Base()
       {
-	if (__pos > __s.size())
+	if (__position > __s.size())
 	  __throw_out_of_range("bitset::bitset initial position not valid");
-	_M_copy_from_string(__s, __pos, __n);
+	_M_copy_from_string(__s, __position, __n);
       }
 
     // 23.3.5.2 bitset operations:
@@ -765,16 +765,16 @@ namespace std
     //@{
     /**
      *  @brief  Operations on bitsets.
-     *  @param  pos  The number of places to shift.
+     *  @param  position  The number of places to shift.
      *
      *  These should be self-explanatory.
     */
     bitset<_Nb>&
-    operator<<=(size_t __pos)
+    operator<<=(size_t __position)
     {
-      if (__builtin_expect(__pos < _Nb, 1))
+      if (__builtin_expect(__position < _Nb, 1))
         {
-          this->_M_do_left_shift(__pos);
+          this->_M_do_left_shift(__position);
           this->_M_do_sanitize();
         }
       else
@@ -783,11 +783,11 @@ namespace std
     }
 
     bitset<_Nb>&
-    operator>>=(size_t __pos)
+    operator>>=(size_t __position)
     {
-      if (__builtin_expect(__pos < _Nb, 1))
+      if (__builtin_expect(__position < _Nb, 1))
         {
-          this->_M_do_right_shift(__pos);
+          this->_M_do_right_shift(__position);
           this->_M_do_sanitize();
         }
       else
@@ -855,16 +855,16 @@ namespace std
 
     /**
      *  @brief Sets a given bit to a particular value.
-     *  @param  pos  The index of the bit.
+     *  @param  position  The index of the bit.
      *  @param  val  Either true or false, defaults to true.
      *  @throw  std::out_of_range  If @a pos is bigger the size of the %set.
     */
     bitset<_Nb>&
-    set(size_t __pos, bool __val = true)
+    set(size_t __position, bool __val = true)
     {
-      if (__pos >= _Nb)
+      if (__position >= _Nb)
 	__throw_out_of_range(__N("bitset::set"));
-      return _Unchecked_set(__pos, __val);
+      return _Unchecked_set(__position, __val);
     }
 
     /**
@@ -879,17 +879,17 @@ namespace std
 
     /**
      *  @brief Sets a given bit to false.
-     *  @param  pos  The index of the bit.
+     *  @param  position  The index of the bit.
      *  @throw  std::out_of_range  If @a pos is bigger the size of the %set.
      *
      *  Same as writing @c set(pos,false).
     */
     bitset<_Nb>&
-    reset(size_t __pos)
+    reset(size_t __position)
     {
-      if (__pos >= _Nb)
+      if (__position >= _Nb)
 	__throw_out_of_range(__N("bitset::reset"));
-      return _Unchecked_reset(__pos);
+      return _Unchecked_reset(__position);
     }
 
     /**
@@ -905,15 +905,15 @@ namespace std
 
     /**
      *  @brief Toggles a given bit to its opposite value.
-     *  @param  pos  The index of the bit.
+     *  @param  position  The index of the bit.
      *  @throw  std::out_of_range  If @a pos is bigger the size of the %set.
     */
     bitset<_Nb>&
-    flip(size_t __pos)
+    flip(size_t __position)
     {
-      if (__pos >= _Nb)
+      if (__position >= _Nb)
 	__throw_out_of_range(__N("bitset::flip"));
-      return _Unchecked_flip(__pos);
+      return _Unchecked_flip(__position);
     }
 
     /// See the no-argument flip().
@@ -923,7 +923,7 @@ namespace std
     //@{
     /**
      *  @brief  Array-indexing support.
-     *  @param  pos  Index into the %bitset.
+     *  @param  position  Index into the %bitset.
      *  @return  A bool for a 'const %bitset'.  For non-const bitsets, an
      *           instance of the reference proxy class.
      *  @note  These operators do no range checking and throw no exceptions,
@@ -938,10 +938,10 @@ namespace std
      *  @endif
     */
     reference
-    operator[](size_t __pos) { return reference(*this,__pos); }
+    operator[](size_t __position) { return reference(*this,__position); }
 
     bool
-    operator[](size_t __pos) const { return _Unchecked_test(__pos); }
+    operator[](size_t __position) const { return _Unchecked_test(__position); }
     //@}
 
     /**
@@ -1007,16 +1007,16 @@ namespace std
 
     /**
      *  @brief Tests the value of a bit.
-     *  @param  pos  The index of a bit.
+     *  @param  position  The index of a bit.
      *  @return  The value at @a pos.
      *  @throw  std::out_of_range  If @a pos is bigger the size of the %set.
     */
     bool
-    test(size_t __pos) const
+    test(size_t __position) const
     {
-      if (__pos >= _Nb)
+      if (__position >= _Nb)
 	__throw_out_of_range(__N("bitset::test"));
-      return _Unchecked_test(__pos);
+      return _Unchecked_test(__position);
     }
 
     /**
@@ -1036,12 +1036,12 @@ namespace std
     //@{
     /// Self-explanatory.
     bitset<_Nb>
-    operator<<(size_t __pos) const
-    { return bitset<_Nb>(*this) <<= __pos; }
+    operator<<(size_t __position) const
+    { return bitset<_Nb>(*this) <<= __position; }
 
     bitset<_Nb>
-    operator>>(size_t __pos) const
-    { return bitset<_Nb>(*this) >>= __pos; }
+    operator>>(size_t __position) const
+    { return bitset<_Nb>(*this) >>= __position; }
     //@}
 
     /**