Makefile.am (install-data-local): Remove pch-install rules.

2007-08-21  Benjamin Kosnik  <bkoz@montsouris.artheist.org>

	* include/Makefile.am (install-data-local): Remove pch-install rules.
	(host_headers): Add stdc++.h, stdtr1c++.h, extc++.h.
	* include/Makefile.in: Regenerate.
	* config.h.in: Same.

	* scripts/check_compile: Remove space between outputs.	
	* include/ext/throw_allocator.h: Correct doxygen markup.	
	* include/bits/char_traits.h: Correct spacing.
	* include/bits/stl_function.h: Same, for 80 column.
	* include/std/valarray: Same.
	* testsuite/util/testsuite_iterators.h: Same.	
	* testsuite/25_algorithms/headers/algorithm/synopsis.cc: Format.

From-SVN: r127685

11 files changed, 520 insertions, 454 deletions

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index 93443df..144ac47 100644
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,18 @@
+2007-08-21  Benjamin Kosnik  <bkoz@montsouris.artheist.org>
+
+	* include/Makefile.am (install-data-local): Remove pch-install rules.
+	(host_headers): Add stdc++.h, stdtr1c++.h, extc++.h.
+	* include/Makefile.in: Regenerate.
+	* config.h.in: Same.
+
+	* scripts/check_compile: Remove space between outputs.	
+	* include/ext/throw_allocator.h: Correct doxygen markup.	
+	* include/bits/char_traits.h: Correct spacing.
+	* include/bits/stl_function.h: Same, for 80 column.
+	* include/std/valarray: Same.
+	* testsuite/util/testsuite_iterators.h: Same.	
+	* testsuite/25_algorithms/headers/algorithm/synopsis.cc: Format.
+	
 2007-08-17  Daniel Jacobowitz  <dan@codesourcery.com>
 
 	PR testsuite/31884
@@ -24,10 +39,14 @@
 	testsuite/ext/throw_allocator/check_deallocate_null.cc,
 	testsuite/ext/throw_allocator/check_new.cc,
 	testsuite/ext/throw_allocator/deallocate_local.cc,
-	testsuite/tr1/5_numerical_facilities/random/subtract_with_carry_01/cons/gen1.cc,
-	testsuite/tr1/5_numerical_facilities/random/subtract_with_carry/cons/gen1.cc,
-	testsuite/tr1/5_numerical_facilities/random/linear_congruential/cons/gen1.cc,
-	testsuite/tr1/5_numerical_facilities/random/mersenne_twister/cons/gen1.cc,
+	testsuite/tr1/5_numerical_facilities/random/subtract_with_carry_01/
+	cons/gen1.cc,
+	testsuite/tr1/5_numerical_facilities/random/subtract_with_carry/cons/
+	gen1.cc,
+	testsuite/tr1/5_numerical_facilities/random/linear_congruential/cons/
+	gen1.cc,
+	testsuite/tr1/5_numerical_facilities/random/mersenne_twister/cons/
+	gen1.cc,
 	testsuite/23_containers/list/modifiers/insert/25288.cc: Use
 	dg-require-time.
 
diff --git a/libstdc++-v3/config.h.in b/libstdc++-v3/config.h.in
index b6d4967..30a03cc 100644
--- a/libstdc++-v3/config.h.in
+++ b/libstdc++-v3/config.h.in
@@ -24,6 +24,9 @@
 /* Define to 1 if you have the `atanl' function. */
 #undef HAVE_ATANL
 
+/* Define to 1 if the target assembler supports thread-local storage. */
+#undef HAVE_CC_TLS
+
 /* Define to 1 if you have the `ceilf' function. */
 #undef HAVE_CEILF
 
diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am
index f661ed4..b7a2a96 100644
--- a/libstdc++-v3/include/Makefile.am
+++ b/libstdc++-v3/include/Makefile.am
@@ -754,7 +754,10 @@ host_headers = \
 	${host_srcdir}/os_defines.h \
 	${glibcxx_srcdir}/$(ATOMIC_WORD_SRCDIR)/atomic_word.h \
 	${glibcxx_srcdir}/$(ABI_TWEAKS_SRCDIR)/cxxabi_tweaks.h \
-	${glibcxx_srcdir}/$(CPU_DEFINES_SRCDIR)/cpu_defines.h	
+	${glibcxx_srcdir}/$(CPU_DEFINES_SRCDIR)/cpu_defines.h \
+	${glibcxx_srcdir}/include/precompiled/stdc++.h \
+	${glibcxx_srcdir}/include/precompiled/stdtr1c++.h \
+	${glibcxx_srcdir}/include/precompiled/extc++.h 
 
 # Non-installed host_header files.
 COMPATIBILITY_H = config/abi/compatibility.h
@@ -809,10 +812,8 @@ pch_output_anchors = \
 PCHFLAGS=-Winvalid-pch -Wno-deprecated -x c++-header $(CXXFLAGS)
 if GLIBCXX_BUILD_PCH
 pch_build = ${pch_output}
-pch_install = install-pch
 else
 pch_build =
-pch_install =
 endif
 
 # List of all timestamp files.  By keeping only one copy of this list, both
@@ -1129,7 +1130,7 @@ ${pch3_output}: ${pch3_source} ${pch2_output}
 # the rest are taken from the original source tree.
 
 if GLIBCXX_HOSTED
-install-data-local: install-headers ${pch_install}
+install-data-local: install-headers 
 else
 install-data-local: install-freestanding-headers
 endif
@@ -1219,16 +1220,6 @@ install-headers:
 	 ${thread_host_headers}; do \
 	  $(INSTALL_DATA) $${file} $(DESTDIR)${host_installdir}; done
 
-install-pch:
-	$(mkinstalldirs) $(DESTDIR)${pch1_output_installdir}
-	for file in ${pch1_output_builddir}/*; do \
-	  $(INSTALL_DATA) $$file $(DESTDIR)${pch1_output_installdir}; done
-	$(mkinstalldirs) $(DESTDIR)${pch2_output_installdir}
-	for file in ${pch2_output_builddir}/*; do \
-	  $(INSTALL_DATA) $$file $(DESTDIR)${pch2_output_installdir}; done
-	$(INSTALL_DATA) ${pch1_output_anchor} $(DESTDIR)${host_installdir}
-	$(INSTALL_DATA) ${pch2_output_anchor} $(DESTDIR)${host_installdir}
-
 # By adding these files here, automake will remove them for 'make clean'
 CLEANFILES = ${pch_output} ${pch_output_anchors}
 
diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in
index 9f5c7fb..876563f 100644
--- a/libstdc++-v3/include/Makefile.in
+++ b/libstdc++-v3/include/Makefile.in
@@ -981,7 +981,10 @@ host_headers = \
 	${host_srcdir}/os_defines.h \
 	${glibcxx_srcdir}/$(ATOMIC_WORD_SRCDIR)/atomic_word.h \
 	${glibcxx_srcdir}/$(ABI_TWEAKS_SRCDIR)/cxxabi_tweaks.h \
-	${glibcxx_srcdir}/$(CPU_DEFINES_SRCDIR)/cpu_defines.h	
+	${glibcxx_srcdir}/$(CPU_DEFINES_SRCDIR)/cpu_defines.h \
+	${glibcxx_srcdir}/include/precompiled/stdc++.h \
+	${glibcxx_srcdir}/include/precompiled/stdtr1c++.h \
+	${glibcxx_srcdir}/include/precompiled/extc++.h 
 
 
 # Non-installed host_header files.
@@ -1035,8 +1038,6 @@ pch_output_anchors = \
 PCHFLAGS = -Winvalid-pch -Wno-deprecated -x c++-header $(CXXFLAGS)
 @GLIBCXX_BUILD_PCH_FALSE@pch_build = 
 @GLIBCXX_BUILD_PCH_TRUE@pch_build = ${pch_output}
-@GLIBCXX_BUILD_PCH_FALSE@pch_install = 
-@GLIBCXX_BUILD_PCH_TRUE@pch_install = install-pch
 
 # List of all timestamp files.  By keeping only one copy of this list, both
 # CLEANFILES and all-local are kept up-to-date.
@@ -1512,7 +1513,7 @@ ${pch3_output}: ${pch3_source} ${pch2_output}
 # host_headers_extra are taken out of the build tree staging area;
 # the rest are taken from the original source tree.
 
-@GLIBCXX_HOSTED_TRUE@install-data-local: install-headers ${pch_install}
+@GLIBCXX_HOSTED_TRUE@install-data-local: install-headers 
 @GLIBCXX_HOSTED_FALSE@install-data-local: install-freestanding-headers
 
 # This is a subset of the full install-headers rule.  We only need <cstddef>,
@@ -1600,16 +1601,6 @@ install-headers:
 	 ${thread_host_headers}; do \
 	  $(INSTALL_DATA) $${file} $(DESTDIR)${host_installdir}; done
 
-install-pch:
-	$(mkinstalldirs) $(DESTDIR)${pch1_output_installdir}
-	for file in ${pch1_output_builddir}/*; do \
-	  $(INSTALL_DATA) $$file $(DESTDIR)${pch1_output_installdir}; done
-	$(mkinstalldirs) $(DESTDIR)${pch2_output_installdir}
-	for file in ${pch2_output_builddir}/*; do \
-	  $(INSTALL_DATA) $$file $(DESTDIR)${pch2_output_installdir}; done
-	$(INSTALL_DATA) ${pch1_output_anchor} $(DESTDIR)${host_installdir}
-	$(INSTALL_DATA) ${pch2_output_anchor} $(DESTDIR)${host_installdir}
-
 # To remove directories.
 clean-local:
 	rm -rf ${pch_output_dirs}
diff --git a/libstdc++-v3/include/bits/char_traits.h b/libstdc++-v3/include/bits/char_traits.h
index a4b4e3a..250faf5 100644
--- a/libstdc++-v3/include/bits/char_traits.h
+++ b/libstdc++-v3/include/bits/char_traits.h
@@ -60,7 +60,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
    *  types, but who don't need to change the definitions of any function
    *  defined in char_traits, can specialize __gnu_cxx::_Char_types
    *  while leaving __gnu_cxx::char_traits alone. */
-  template <class _CharT>
+  template<typename _CharT>
     struct _Char_types
     {
       typedef unsigned long   int_type;
diff --git a/libstdc++-v3/include/bits/stl_function.h b/libstdc++-v3/include/bits/stl_function.h
index 1bd11a3..7dc5031 100644
--- a/libstdc++-v3/include/bits/stl_function.h
+++ b/libstdc++-v3/include/bits/stl_function.h
@@ -124,9 +124,11 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
 
   // 20.3.2 arithmetic
   /** @defgroup s20_3_2_arithmetic Arithmetic Classes
-   *  Because basic math often needs to be done during an algorithm, the library
-   *  provides functors for those operations.  See the documentation for
-   *  @link s20_3_1_base the base classes@endlink for examples of their use.
+
+   *  Because basic math often needs to be done during an algorithm,
+   *  the library provides functors for those operations.  See the
+   *  documentation for @link s20_3_1_base the base classes@endlink
+   *  for examples of their use.
    *
    *  @{
    */
@@ -249,7 +251,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
 
   // 20.3.4 logical operations
   /** @defgroup s20_3_4_logical Boolean Operations Classes
-   *  Here are wrapper functors for Boolean operations:  @c &&, @c ||, and @c !.
+   *  Here are wrapper functors for Boolean operations: @c &&, @c ||,
+   *  and @c !.
    *
    *  @{
    */
@@ -360,15 +363,14 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
   template <class _Predicate>
     class binary_negate
     : public binary_function<typename _Predicate::first_argument_type,
-			     typename _Predicate::second_argument_type,
-			     bool>
+			     typename _Predicate::second_argument_type, bool>
     {
     protected:
       _Predicate _M_pred;
+
     public:
       explicit
-      binary_negate(const _Predicate& __x)
-      : _M_pred(__x) { }
+      binary_negate(const _Predicate& __x) : _M_pred(__x) { }
 
       bool
       operator()(const typename _Predicate::first_argument_type& __x,
@@ -605,7 +607,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
    *
    *  @{
    */
-  /// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
+  /// One of the @link s20_3_8_memadaptors adaptors for member
+  /// pointers@endlink.
   template <class _Ret, class _Tp>
     class mem_fun_t : public unary_function<_Tp*, _Ret>
     {
@@ -621,7 +624,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
       _Ret (_Tp::*_M_f)();
     };
 
-  /// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
+  /// One of the @link s20_3_8_memadaptors adaptors for member
+  /// pointers@endlink.
   template <class _Ret, class _Tp>
     class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
     {
@@ -637,7 +641,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
       _Ret (_Tp::*_M_f)() const;
     };
 
-  /// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
+  /// One of the @link s20_3_8_memadaptors adaptors for member
+  /// pointers@endlink.
   template <class _Ret, class _Tp>
     class mem_fun_ref_t : public unary_function<_Tp, _Ret>
     {
@@ -653,7 +658,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
       _Ret (_Tp::*_M_f)();
   };
 
-  /// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
+  /// One of the @link s20_3_8_memadaptors adaptors for member
+  /// pointers@endlink.
   template <class _Ret, class _Tp>
     class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
     {
@@ -669,7 +675,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
       _Ret (_Tp::*_M_f)() const;
     };
 
-  /// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
+  /// One of the @link s20_3_8_memadaptors adaptors for member
+  /// pointers@endlink.
   template <class _Ret, class _Tp, class _Arg>
     class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
     {
@@ -685,7 +692,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
       _Ret (_Tp::*_M_f)(_Arg);
     };
 
-  /// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
+  /// One of the @link s20_3_8_memadaptors adaptors for member
+  /// pointers@endlink.
   template <class _Ret, class _Tp, class _Arg>
     class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
     {
@@ -701,7 +709,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
       _Ret (_Tp::*_M_f)(_Arg) const;
     };
 
-  /// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
+  /// One of the @link s20_3_8_memadaptors adaptors for member
+  /// pointers@endlink.
   template <class _Ret, class _Tp, class _Arg>
     class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
     {
@@ -717,7 +726,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
       _Ret (_Tp::*_M_f)(_Arg);
     };
 
-  /// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
+  /// One of the @link s20_3_8_memadaptors adaptors for member
+  /// pointers@endlink.
   template <class _Ret, class _Tp, class _Arg>
     class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
     {
diff --git a/libstdc++-v3/include/ext/throw_allocator.h b/libstdc++-v3/include/ext/throw_allocator.h
index 9a3dbef..78b78f1 100644
--- a/libstdc++-v3/include/ext/throw_allocator.h
+++ b/libstdc++-v3/include/ext/throw_allocator.h
@@ -39,7 +39,7 @@
 // purpose. It is provided "as is" without express or implied
 // warranty.
 
-/** @file ext/vstring.h
+/** @file ext/throw_allocator.h
  *  This file is a GNU extension to the Standard C++ Library.
  *
  *  Contains an exception-throwing allocator, useful for testing
@@ -47,10 +47,6 @@
  *  sanity checked.
  */
 
-/**
- * @file throw_allocator.h 
- */
-
 #ifndef _THROW_ALLOCATOR_H
 #define _THROW_ALLOCATOR_H 1
 
diff --git a/libstdc++-v3/include/std/valarray b/libstdc++-v3/include/std/valarray
index c8084fd..31799c0 100644
--- a/libstdc++-v3/include/std/valarray
+++ b/libstdc++-v3/include/std/valarray
@@ -881,7 +881,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
     valarray<_Tp>::min() const
     {
       _GLIBCXX_DEBUG_ASSERT(_M_size > 0);
-      return *std::min_element(_M_data, _M_data+_M_size);
+      return *std::min_element(_M_data, _M_data + _M_size);
     }
 
   template<typename _Tp>
@@ -889,7 +889,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
     valarray<_Tp>::max() const
     {
       _GLIBCXX_DEBUG_ASSERT(_M_size > 0);
-      return *std::max_element(_M_data, _M_data+_M_size);
+      return *std::max_element(_M_data, _M_data + _M_size);
     }
   
   template<class _Tp>
diff --git a/libstdc++-v3/scripts/check_compile b/libstdc++-v3/scripts/check_compile
index c969f98..76762e6 100755
--- a/libstdc++-v3/scripts/check_compile
+++ b/libstdc++-v3/scripts/check_compile
@@ -28,7 +28,7 @@ PCH_FLAGS=`$flags_script --cxxpchflags`
 FLAGS=`$flags_script --cxxflags`
 TEST_FLAGS="-S"
 COMPILER=`$flags_script --build-cxx`
-CXX="$COMPILER $INCLUDES $PCH_FLAGS $FLAGS $TEST_FLAGS"
+CXX="$COMPILER $INCLUDES $PCH_FLAGS $FLAGS -Wfatal-errors $TEST_FLAGS"
 
 echo "compile line is:"
 echo $CXX
@@ -49,7 +49,6 @@ do
 #	mv $OUTPUT_NAME binaries
 	rm $OUTPUT_NAME
     fi
-    echo ""
     let UNIQUE_ID+=1 
   fi
 done
diff --git a/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc b/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc
index 032fa31..800de34 100644
--- a/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc
+++ b/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc
@@ -20,385 +20,442 @@
 
 #include <algorithm>
 
-namespace std {
+namespace std
+ {
   // 25.1, non-modifying sequence operations:
-  template<class InputIterator, class Function>
-    Function for_each(InputIterator first, InputIterator last, Function f);
-  template<class InputIterator, class T>
-    InputIterator find(InputIterator first, InputIterator last,
-                               const T& value);
-  template<class InputIterator, class Predicate>
-    InputIterator find_if(InputIterator first, InputIterator last,
-                                   Predicate pred);
-  template<class ForwardIterator1, class ForwardIterator2>
-    ForwardIterator1
-       find_end(ForwardIterator1 first1, ForwardIterator1 last1,
-                    ForwardIterator2 first2, ForwardIterator2 last2);
-  template<class ForwardIterator1, class ForwardIterator2,
-               class BinaryPredicate>
-    ForwardIterator1
-       find_end(ForwardIterator1 first1, ForwardIterator1 last1,
-                    ForwardIterator2 first2, ForwardIterator2 last2,
-                    BinaryPredicate pred);
-  template<class ForwardIterator1, class ForwardIterator2>
-    ForwardIterator1
-       find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
-                           ForwardIterator2 first2, ForwardIterator2 last2);
-  template<class ForwardIterator1, class ForwardIterator2,
-               class BinaryPredicate>
-    ForwardIterator1
-       find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
-                    ForwardIterator2 first2, ForwardIterator2 last2,
-                    BinaryPredicate pred);
-
-template<class ForwardIterator>
-  ForwardIterator adjacent_find(ForwardIterator first,
-                                ForwardIterator last);
-
-template<class ForwardIterator, class BinaryPredicate>
-  ForwardIterator adjacent_find(ForwardIterator first,
-      ForwardIterator last, BinaryPredicate pred);
-
-template<class InputIterator, class T>
-  typename iterator_traits<InputIterator>::difference_type
-    count(InputIterator first, InputIterator last, const T& value);
-
-template<class InputIterator, class Predicate>
-  typename iterator_traits<InputIterator>::difference_type
-    count_if(InputIterator first, InputIterator last, Predicate pred);
-template<class InputIterator1, class InputIterator2>
-  pair<InputIterator1, InputIterator2>
-    mismatch(InputIterator1 first1, InputIterator1 last1,
-             InputIterator2 first2);
-template
- <class InputIterator1, class InputIterator2, class BinaryPredicate>
-  pair<InputIterator1, InputIterator2>
-    mismatch(InputIterator1 first1, InputIterator1 last1,
-      InputIterator2 first2, BinaryPredicate pred);
-template<class InputIterator1, class InputIterator2>
-  bool equal(InputIterator1 first1, InputIterator1 last1,
-             InputIterator2 first2);
-template
- <class InputIterator1, class InputIterator2, class BinaryPredicate>
-  bool equal(InputIterator1 first1, InputIterator1 last1,
-             InputIterator2 first2, BinaryPredicate pred);
-
-template<class ForwardIterator1, class ForwardIterator2>
-  ForwardIterator1 search
-    (ForwardIterator1 first1, ForwardIterator1 last1,
-     ForwardIterator2 first2, ForwardIterator2 last2);
-
-template<class ForwardIterator1, class ForwardIterator2,
-         class BinaryPredicate>
-  ForwardIterator1 search
-    (ForwardIterator1 first1, ForwardIterator1 last1,
-     ForwardIterator2 first2, ForwardIterator2 last2,
-                          BinaryPredicate pred);
-
-template<class ForwardIterator, class Size, class T>
-  ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
-                          Size count, const T& value);
-
-template <class ForwardIterator, class Size, class T, class BinaryPredicate>
-  ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
-                          Size count, const T& value,
-                          BinaryPredicate pred);
-
-// 25.2, modifying sequence operations:
-// 25.2.1, copy:
-template<class InputIterator, class OutputIterator>
-  OutputIterator copy(InputIterator first, InputIterator last,
-                               OutputIterator result);
-template<class BidirectionalIterator1, class BidirectionalIterator2>
-  BidirectionalIterator2
-     copy_backward
-         (BidirectionalIterator1 first, BidirectionalIterator1 last,
-          BidirectionalIterator2 result);
-// 25.2.2, swap:
-template<class T> void swap(T& a, T& b);
-template<class ForwardIterator1, class ForwardIterator2>
-  ForwardIterator2 swap_ranges(ForwardIterator1 first1,
-         ForwardIterator1 last1, ForwardIterator2 first2);
-template<class ForwardIterator1, class ForwardIterator2>
-  void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
-template<class InputIterator, class OutputIterator, class UnaryOperation>
-  OutputIterator transform(InputIterator first, InputIterator last,
-                                      OutputIterator result, UnaryOperation op);
-template<class InputIterator1, class InputIterator2, class OutputIterator,
-             class BinaryOperation>
-  OutputIterator transform(InputIterator1 first1, InputIterator1 last1,
-                                      InputIterator2 first2, OutputIterator result,
-                                      BinaryOperation binary_op);
-template<class ForwardIterator, class T>
-  void replace(ForwardIterator first, ForwardIterator last,
-                     const T& old_value, const T& new_value);
-template<class ForwardIterator, class Predicate, class T>
-  void replace_if(ForwardIterator first, ForwardIterator last,
-                         Predicate pred, const T& new_value);
-template<class InputIterator, class OutputIterator, class T>
-  OutputIterator replace_copy(InputIterator first, InputIterator last,
-                                         OutputIterator result,
-                                         const T& old_value, const T& new_value);
-template<class Iterator, class OutputIterator, class Predicate, class T>
-  OutputIterator replace_copy_if(Iterator first, Iterator last,
-                                            OutputIterator result,
-                                            Predicate pred, const T& new_value);
-template<class ForwardIterator, class T>
-  void fill(ForwardIterator first, ForwardIterator last, const T& value);
-template<class OutputIterator, class Size, class T>
-  void fill_n(OutputIterator first, Size n, const T& value);
-template<class ForwardIterator, class Generator>
-  void generate(ForwardIterator first, ForwardIterator last,
-                       Generator gen);
-template<class OutputIterator, class Size, class Generator>
-  void generate_n(OutputIterator first, Size n, Generator gen);
-
-template<class ForwardIterator, class T>
-  ForwardIterator remove(ForwardIterator first, ForwardIterator last,
-                                const T& value);
-template<class ForwardIterator, class Predicate>
-  ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
-                                   Predicate pred);
-template<class InputIterator, class OutputIterator, class T>
-  OutputIterator remove_copy(InputIterator first, InputIterator last,
-                                    OutputIterator result, const T& value);
-template<class InputIterator, class OutputIterator, class Predicate>
-  OutputIterator remove_copy_if(InputIterator first, InputIterator last,
-                                       OutputIterator result, Predicate pred);
-template<class ForwardIterator>
-  ForwardIterator unique(ForwardIterator first, ForwardIterator last);
-template<class ForwardIterator, class BinaryPredicate>
-  ForwardIterator unique(ForwardIterator first, ForwardIterator last,
-                                BinaryPredicate pred);
-template<class InputIterator, class OutputIterator>
-  OutputIterator unique_copy(InputIterator first, InputIterator last,
-                                    OutputIterator result);
-template<class InputIterator, class OutputIterator, class BinaryPredicate>
-  OutputIterator unique_copy(InputIterator first, InputIterator last,
-                                    OutputIterator result, BinaryPredicate pred);
-template<class BidirectionalIterator>
-  void reverse(BidirectionalIterator first, BidirectionalIterator last);
-template<class BidirectionalIterator, class OutputIterator>
-  OutputIterator reverse_copy(BidirectionalIterator first,
-                                     BidirectionalIterator last,
-                                     OutputIterator result);
-template<class ForwardIterator>
-  void rotate(ForwardIterator first, ForwardIterator middle,
-                     ForwardIterator last);
-template<class ForwardIterator, class OutputIterator>
-  OutputIterator rotate_copy
-     (ForwardIterator first, ForwardIterator middle,
-       ForwardIterator last, OutputIterator result);
-template<class RandomAccessIterator>
-  void random_shuffle(RandomAccessIterator first,
-                             RandomAccessIterator last);
-template<class RandomAccessIterator, class RandomNumberGenerator>
-  void random_shuffle(RandomAccessIterator first,
-                             RandomAccessIterator last,
-                             RandomNumberGenerator& rand);
-// 25.2.12, partitions:
-template<class BidirectionalIterator, class Predicate>
-  BidirectionalIterator partition(BidirectionalIterator first,
-                                         BidirectionalIterator last,
-                                         Predicate pred);
-template<class BidirectionalIterator, class Predicate>
-  BidirectionalIterator stable_partition(BidirectionalIterator first,
-                                                 BidirectionalIterator last,
-                                                Predicate pred);
-// 25.3, sorting and related operations:
-// 25.3.1, sorting:
-template<class RandomAccessIterator>
-  void sort(RandomAccessIterator first, RandomAccessIterator last);
-template<class RandomAccessIterator, class Compare>
-  void sort(RandomAccessIterator first, RandomAccessIterator last,
-                  Compare comp);
-template<class RandomAccessIterator>
-  void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
-template<class RandomAccessIterator, class Compare>
-  void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
-                            Compare comp);
-template<class RandomAccessIterator>
-  void partial_sort(RandomAccessIterator first,
-                              RandomAccessIterator middle,
-                              RandomAccessIterator last);
-template<class RandomAccessIterator, class Compare>
-  void partial_sort(RandomAccessIterator first,
-                              RandomAccessIterator middle,
-                              RandomAccessIterator last, Compare comp);
-template<class InputIterator, class RandomAccessIterator>
-  RandomAccessIterator
-     partial_sort_copy(InputIterator first, InputIterator last,
-                                RandomAccessIterator result_first,
-                                RandomAccessIterator result_last);
-template<class InputIterator, class RandomAccessIterator, class Compare>
-  RandomAccessIterator
-     partial_sort_copy(InputIterator first, InputIterator last,
-                                RandomAccessIterator result_first,
-                                RandomAccessIterator result_last,
-                                Compare comp);
-template<class RandomAccessIterator>
-  void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
-                            RandomAccessIterator last);
-template<class RandomAccessIterator, class Compare>
-  void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
-                            RandomAccessIterator last, Compare comp);
-// 25.3.3, binary search:
-template<class ForwardIterator, class T>
-  ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
-                                         const T& value);
-template<class ForwardIterator, class T, class Compare>
-  ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
-                                         const T& value, Compare comp);
-template<class ForwardIterator, class T>
-  ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
-                                         const T& value);
-template<class ForwardIterator, class T, class Compare>
-  ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
-                                         const T& value, Compare comp);
-template<class ForwardIterator, class T>
-  pair<ForwardIterator, ForwardIterator>
-     equal_range(ForwardIterator first, ForwardIterator last,
-                        const T& value);
-template<class ForwardIterator, class T, class Compare>
-  pair<ForwardIterator, ForwardIterator>
-     equal_range(ForwardIterator first, ForwardIterator last,
-                        const T& value, Compare comp);
-template<class ForwardIterator, class T>
-  bool binary_search(ForwardIterator first, ForwardIterator last,
-                             const T& value);
-template<class ForwardIterator, class T, class Compare>
-  bool binary_search(ForwardIterator first, ForwardIterator last,
-                             const T& value, Compare comp);
-// 25.3.4, merge:
-template<class InputIterator1, class InputIterator2, class OutputIterator>
-  OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
-                               InputIterator2 first2, InputIterator2 last2,
-                               OutputIterator result);
-template<class InputIterator1, class InputIterator2, class OutputIterator,
-             class Compare>
-  OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
-                               InputIterator2 first2, InputIterator2 last2,
-                               OutputIterator result, Compare comp);
-template<class BidirectionalIterator>
-  void inplace_merge(BidirectionalIterator first,
-                             BidirectionalIterator middle,
-                             BidirectionalIterator last);
-template<class BidirectionalIterator, class Compare>
-  void inplace_merge(BidirectionalIterator first,
-                             BidirectionalIterator middle,
-                             BidirectionalIterator last, Compare comp);
-// 25.3.5, set operations:
-template<class InputIterator1, class InputIterator2>
-  bool includes(InputIterator1 first1, InputIterator1 last1,
-                        InputIterator2 first2, InputIterator2 last2);
-template<class InputIterator1, class InputIterator2, class Compare>
-  bool includes
-     (InputIterator1 first1, InputIterator1 last1,
-       InputIterator2 first2, InputIterator2 last2, Compare comp);
-template<class InputIterator1, class InputIterator2, class OutputIterator>
-  OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
-                                   InputIterator2 first2, InputIterator2 last2,
-                                   OutputIterator result);
-template<class InputIterator1, class InputIterator2, class OutputIterator,
-             class Compare>
-  OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
-                                   InputIterator2 first2, InputIterator2 last2,
-                                   OutputIterator result, Compare comp);
-template<class InputIterator1, class InputIterator2, class OutputIterator>
-  OutputIterator set_intersection
-        (InputIterator1 first1, InputIterator1 last1,
-          InputIterator2 first2, InputIterator2 last2,
-          OutputIterator result);
-template<class InputIterator1, class InputIterator2, class OutputIterator,
-             class Compare>
-  OutputIterator set_intersection
-        (InputIterator1 first1, InputIterator1 last1,
-          InputIterator2 first2, InputIterator2 last2,
-          OutputIterator result, Compare comp);
-template<class InputIterator1, class InputIterator2, class OutputIterator>
-  OutputIterator set_difference
-        (InputIterator1 first1, InputIterator1 last1,
-          InputIterator2 first2, InputIterator2 last2,
-          OutputIterator result);
-template<class InputIterator1, class InputIterator2, class OutputIterator,
-             class Compare>
-  OutputIterator set_difference
-        (InputIterator1 first1, InputIterator1 last1,
-          InputIterator2 first2, InputIterator2 last2,
-          OutputIterator result, Compare comp);
-template<class InputIterator1, class InputIterator2, class OutputIterator>
-  OutputIterator
-     set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
-                                    InputIterator2 first2, InputIterator2 last2,
-                                    OutputIterator result);
-template<class InputIterator1, class InputIterator2, class OutputIterator,
-              class Compare>
-  OutputIterator
-     set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
-                                    InputIterator2 first2, InputIterator2 last2,
-                                    OutputIterator result, Compare comp);
-// 25.3.6, heap operations:
-template<class RandomAccessIterator>
-  void push_heap(RandomAccessIterator first, RandomAccessIterator last);
-template<class RandomAccessIterator, class Compare>
-  void push_heap(RandomAccessIterator first, RandomAccessIterator last,
-                        Compare comp);
-template<class RandomAccessIterator>
-  void pop_heap(RandomAccessIterator first, RandomAccessIterator last);
-template<class RandomAccessIterator, class Compare>
-  void pop_heap(RandomAccessIterator first, RandomAccessIterator last,
-                       Compare comp);
-template<class RandomAccessIterator>
-  void make_heap(RandomAccessIterator first, RandomAccessIterator last);
-template<class RandomAccessIterator, class Compare>
-  void make_heap(RandomAccessIterator first, RandomAccessIterator last,
-                        Compare comp);
-template<class RandomAccessIterator>
-  void sort_heap(RandomAccessIterator first, RandomAccessIterator last);
-template<class RandomAccessIterator, class Compare>
-  void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
-                        Compare comp);
+  template<typename _IIter, typename _Funct>
+    _Funct 
+    for_each(_IIter, _IIter, _Funct);
+
+  template<typename _IIter, typename _Tp>
+    _IIter 
+    find(_IIter, _IIter, const _Tp&);
+
+  template<typename _IIter, typename _Predicate>
+    _IIter 
+    find_if(_IIter, _IIter, _Predicate);
+
+  template<typename _FIter1, typename _FIter2>
+    _FIter1
+    find_end(_FIter1, _FIter1, _FIter2, _FIter2);
+
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+    _FIter1
+    find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+
+  template<typename _FIter1, typename _FIter2>
+    _FIter1
+    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
+
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+    _FIter1
+    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+
+  template<typename _FIter>
+    _FIter 
+    adjacent_find(_FIter, _FIter);
+
+  template<typename _FIter, typename _BinaryPredicate>
+    _FIter 
+    adjacent_find(_FIter, _FIter, _BinaryPredicate);
+
+  template<typename _IIter, typename _Tp>
+    typename iterator_traits<_IIter>::difference_type
+    count(_IIter, _IIter, const _Tp&);
+
+  template<typename _IIter, typename _Predicate>
+    typename iterator_traits<_IIter>::difference_type
+    count_if(_IIter, _IIter, _Predicate);
+
+  template<typename _IIter1, typename _IIter2>
+    pair<_IIter1, _IIter2>
+    mismatch(_IIter1, _IIter1, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    pair<_IIter1, _IIter2>
+    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
+
+  template<typename _IIter1, typename _IIter2>
+    bool 
+    equal(_IIter1, _IIter1, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    bool 
+    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
+
+  template<typename _FIter1, typename _FIter2>
+    _FIter1 
+    search(_FIter1, _FIter1, _FIter2, _FIter2);
+
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+    _FIter1 
+    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+
+  template<typename _FIter, typename _Size, typename _Tp>
+    _FIter 
+    search_n(_FIter, _FIter, _Size, const _Tp&);
+
+  template<typename _FIter, typename _Size, typename _Tp, 
+	   typename _BinaryPredicate>
+    _FIter 
+    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
+
+  // 25.2, modifying sequence operations:
+  // 25.2.1, copy:
+  template<typename _IIter, typename _OIter>
+    _OIter 
+    copy(_IIter, _IIter, _OIter);
+
+  template<typename _BIter1, typename _BIter2>
+    _BIter2
+    copy_backward (_BIter1, _BIter1, _BIter2);
+
+  // 25.2.2, swap:
+  template<typename _Tp> 
+    void 
+    swap(_Tp&, _Tp& b);
+
+  template<typename _FIter1, typename _FIter2>
+    _FIter2 
+    swap_ranges(_FIter1 first1, _FIter1, _FIter2);
+
+  template<typename _FIter1, typename _FIter2>
+    void 
+    iter_swap(_FIter1, _FIter2 b);
+
+  template<typename _IIter, typename _OIter, typename _UnaryOperation>
+    _OIter 
+    transform(_IIter, _IIter, _OIter, _UnaryOperation op);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter, 
+	   typename _BinaryOperation>
+    _OIter 
+    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
+
+  template<typename _FIter, typename _Tp>
+    void 
+    replace(_FIter, _FIter, const _Tp&, const _Tp&);
+
+  template<typename _FIter, typename _Predicate, typename _Tp>
+    void 
+    replace_if(_FIter, _FIter, _Predicate, const _Tp&);
+
+  template<typename _IIter, typename _OIter, typename _Tp>
+    _OIter 
+    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
+
+  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
+    _OIter 
+    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
+
+  template<typename _FIter, typename _Tp>
+    void 
+    fill(_FIter, _FIter, const _Tp&);
+
+  template<typename _OIter, typename _Size, typename _Tp>
+    void 
+    fill_n(_OIter, _Size n, const _Tp&);
+
+  template<typename _FIter, typename _Generator>
+    void 
+    generate(_FIter, _FIter, _Generator);
+
+  template<typename _OIter, typename _Size, typename _Generator>
+    void 
+    generate_n(_OIter, _Size, _Generator);
+
+  template<typename _FIter, typename _Tp>
+    _FIter 
+    remove(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Predicate>
+    _FIter 
+    remove_if(_FIter, _FIter, _Predicate);
+
+  template<typename _IIter, typename _OIter, typename _Tp>
+    _OIter 
+    remove_copy(_IIter, _IIter, _OIter, const _Tp&);
+
+  template<typename _IIter, typename _OIter, typename _Predicate>
+    _OIter 
+    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
+
+  template<typename _FIter>
+    _FIter 
+    unique(_FIter, _FIter);
+
+  template<typename _FIter, typename _BinaryPredicate>
+    _FIter 
+    unique(_FIter, _FIter, _BinaryPredicate);
+
+  template<typename _IIter, typename _OIter>
+    _OIter 
+    unique_copy(_IIter, _IIter, _OIter);
+
+  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
+    _OIter 
+    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
+
+  template<typename _BIter>
+    void 
+    reverse(_BIter, _BIter);
+
+  template<typename _BIter, typename _OIter>
+    _OIter 
+    reverse_copy(_BIter, _BIter, _OIter);
+
+  template<typename _FIter>
+    void 
+    rotate(_FIter, _FIter, _FIter);
+
+  template<typename _FIter, typename _OIter>
+    _OIter 
+    rotate_copy (_FIter, _FIter, _FIter, _OIter);
+
+  template<typename _RAIter>
+    void 
+    random_shuffle(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Generator>
+    void 
+    random_shuffle(_RAIter, _RAIter, _Generator&);
+
+  // 25.2.12, partitions:
+  template<typename _BIter, typename _Predicate>
+    _BIter 
+    partition(_BIter, _BIter, _Predicate);
+
+  template<typename _BIter, typename _Predicate>
+    _BIter 
+    stable_partition(_BIter, _BIter, _Predicate);
+
+  // 25.3, sorting and related operations:
+  // 25.3.1, sorting:
+  template<typename _RAIter>
+    void 
+    sort(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void 
+    sort(_RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+    void 
+    stable_sort(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void 
+    stable_sort(_RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+    void 
+    partial_sort(_RAIter, _RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void 
+    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
+
+  template<typename _IIter, typename _RAIter>
+    _RAIter
+    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
+
+  template<typename _IIter, typename _RAIter, typename _Compare>
+    _RAIter
+    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+    void 
+    nth_element(_RAIter, _RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void 
+    nth_element(_RAIter, _RAIter, _RAIter, _Compare);
+
+  // 25.3.3, binary search:
+  template<typename _FIter, typename _Tp>
+    _FIter 
+    lower_bound(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+    _FIter 
+    lower_bound(_FIter, _FIter, const _Tp&, _Compare);
+
+  template<typename _FIter, typename _Tp>
+    _FIter 
+    upper_bound(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+    _FIter 
+    upper_bound(_FIter, _FIter, const _Tp&, _Compare);
+
+  template<typename _FIter, typename _Tp>
+    pair<_FIter, _FIter>
+    equal_range(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+    pair<_FIter, _FIter>
+    equal_range(_FIter, _FIter, const _Tp&, _Compare);
+
+  template<typename _FIter, typename _Tp>
+    bool 
+    binary_search(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+    bool 
+    binary_search(_FIter, _FIter, const _Tp&, _Compare);
+
+  // 25.3.4, merge:
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter 
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter, 
+	   typename _Compare>
+    _OIter 
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _BIter>
+    void 
+    inplace_merge(_BIter, _BIter, _BIter);
+
+  template<typename _BIter, typename _Compare>
+    void 
+    inplace_merge(_BIter, _BIter, _BIter, _Compare);
+
+  // 25.3.5, set operations:
+  template<typename _IIter1, typename _IIter2>
+    bool 
+    includes(_IIter1, _IIter1, _IIter2, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _Compare>
+    bool 
+    includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter 
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Compare>
+    _OIter 
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter 
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Compare>
+    _OIter 
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter 
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter, 
+	   typename _Compare>
+    _OIter 
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter, 
+	   typename _Compare>
+    _OIter
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, 
+			     _OIter, _Compare);
+
+  // 25.3.6, heap operations:
+  template<typename _RAIter>
+    void 
+    push_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void 
+    push_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+    void 
+    pop_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void 
+    pop_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+    void 
+    make_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void 
+    make_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+    void 
+    sort_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void 
+    sort_heap(_RAIter, _RAIter, _Compare);
 
   // 25.3.7, minimum and maximum:
-  template<class T> const T& min(const T& a, const T& b);
-  template<class T, class Compare>
-    const T& min(const T& a, const T& b, Compare comp);
-  template<class T> const T& max(const T& a, const T& b);
-  template<class T, class Compare>
-    const T& max(const T& a, const T& b, Compare comp);
-  template<class ForwardIterator>
-    ForwardIterator min_element
-       (ForwardIterator first, ForwardIterator last);
-  template<class ForwardIterator, class Compare>
-    ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
-                                     Compare comp);
-  template<class ForwardIterator>
-    ForwardIterator max_element
-       (ForwardIterator first, ForwardIterator last);
-  template<class ForwardIterator, class Compare>
-    ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
-                                     Compare comp);
-  template<class InputIterator1, class InputIterator2>
-    bool lexicographical_compare
-          (InputIterator1 first1, InputIterator1 last1,
-            InputIterator2 first2, InputIterator2 last2);
-  template<class InputIterator1, class InputIterator2, class Compare>
-    bool lexicographical_compare
-          (InputIterator1 first1, InputIterator1 last1,
-            InputIterator2 first2, InputIterator2 last2,
-            Compare comp);
+  template<typename _Tp> 
+    const _Tp& 
+    min(const _Tp&, const _Tp&);
+
+  template<typename _Tp, typename _Compare>
+    const _Tp& 
+    min(const _Tp&, const _Tp&, _Compare);
+
+  template<typename _Tp> 
+    const _Tp& 
+    max(const _Tp&, const _Tp&);
+
+  template<typename _Tp, typename _Compare>
+    const _Tp& 
+    max(const _Tp&, const _Tp&, _Compare);
+
+  template<typename _FIter>
+    _FIter 
+    min_element(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    _FIter 
+    min_element(_FIter, _FIter, _Compare);
+
+  template<typename _FIter>
+    _FIter 
+    max_element(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    _FIter 
+    max_element(_FIter, _FIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2>
+    bool 
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _Compare>
+    bool 
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
 
   // 25.3.9, permutations
-  template<class BidirectionalIterator>
-    bool next_permutation(BidirectionalIterator first,
-                                 BidirectionalIterator last);
-  template<class BidirectionalIterator, class Compare>
-    bool next_permutation(BidirectionalIterator first,
-                                 BidirectionalIterator last, Compare comp);
-  template<class BidirectionalIterator>
-    bool prev_permutation(BidirectionalIterator first,
-                                 BidirectionalIterator last);
-  template<class BidirectionalIterator, class Compare>
-    bool prev_permutation(BidirectionalIterator first,
-                                 BidirectionalIterator last, Compare comp);
+  template<typename _BIter>
+    bool 
+    next_permutation(_BIter, _BIter);
+
+  template<typename _BIter, typename _Compare>
+    bool 
+    next_permutation(_BIter, _BIter, _Compare);
+
+  template<typename _BIter>
+    bool 
+    prev_permutation(_BIter, _BIter);
+
+  template<typename _BIter, typename _Compare>
+    bool 
+    prev_permutation(_BIter, _BIter, _Compare);
 }
diff --git a/libstdc++-v3/testsuite/util/testsuite_iterators.h b/libstdc++-v3/testsuite/util/testsuite_iterators.h
index 073be0b..7600867 100644
--- a/libstdc++-v3/testsuite/util/testsuite_iterators.h
+++ b/libstdc++-v3/testsuite/util/testsuite_iterators.h
@@ -61,8 +61,7 @@ namespace __gnu_test
     {
       T* first;
       T* last;
-      BoundsContainer(T* _first, T* _last)
-	: first(_first), last(_last)
+      BoundsContainer(T* _first, T* _last) : first(_first), last(_last)
       { }
     };
 
@@ -73,7 +72,7 @@ namespace __gnu_test
       T* incrementedto;
       bool* writtento;
       OutputContainer(T* _first, T* _last)
-	: BoundsContainer<T>(_first, _last), incrementedto(_first)
+      : BoundsContainer<T>(_first, _last), incrementedto(_first)
       {
 	writtento = new bool[this->last - this->first];
 	for(int i = 0; i < this->last - this->first; i++)
@@ -114,21 +113,21 @@ namespace __gnu_test
    * instansiated directly, but generated from a test_container
    */
   template<class T>
-  struct output_iterator_wrapper: public std::iterator
-  <std::output_iterator_tag, T, ptrdiff_t, T*, T&>
+  struct output_iterator_wrapper
+  : public std::iterator<std::output_iterator_tag, T, ptrdiff_t, T*, T&>
   {
     typedef OutputContainer<T> ContainerType;
     T* ptr;
     ContainerType* SharedInfo;
 
     output_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
-      :ptr(_ptr), SharedInfo(SharedInfo_in)
+    : ptr(_ptr), SharedInfo(SharedInfo_in)
     {
       ITERATOR_VERIFY(ptr >= SharedInfo->first && ptr <= SharedInfo->last);
     }
     
     output_iterator_wrapper(const output_iterator_wrapper& in)
-      :ptr(in.ptr), SharedInfo(in.SharedInfo)
+    : ptr(in.ptr), SharedInfo(in.SharedInfo)
     { }
 
     WritableObject<T>
@@ -175,8 +174,8 @@ namespace __gnu_test
    * instansiated directly, but generated from a test_container
    */
   template<class T>
-  class input_iterator_wrapper:public std::iterator
-  <std::input_iterator_tag, T, ptrdiff_t, T*, T&>
+  class input_iterator_wrapper
+  : public std::iterator<std::input_iterator_tag, T, ptrdiff_t, T*, T&>
   {
   protected:
     input_iterator_wrapper()
@@ -188,11 +187,11 @@ namespace __gnu_test
     ContainerType* SharedInfo;
 
     input_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
-      : ptr(_ptr), SharedInfo(SharedInfo_in)
+    : ptr(_ptr), SharedInfo(SharedInfo_in)
     { ITERATOR_VERIFY(ptr >= SharedInfo->first && ptr <= SharedInfo->last); }
     
     input_iterator_wrapper(const input_iterator_wrapper& in)
-      : ptr(in.ptr), SharedInfo(in.SharedInfo)
+    : ptr(in.ptr), SharedInfo(in.SharedInfo)
     { }
 
     bool
@@ -257,16 +256,16 @@ namespace __gnu_test
    * instansiated directly, but generated from a test_container
    */
   template<class T>
-  struct forward_iterator_wrapper:public input_iterator_wrapper<T>
+  struct forward_iterator_wrapper : public input_iterator_wrapper<T>
   {
     typedef BoundsContainer<T> ContainerType;
     typedef std::forward_iterator_tag iterator_category;
     forward_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
-      :input_iterator_wrapper<T>(_ptr, SharedInfo_in)
+    : input_iterator_wrapper<T>(_ptr, SharedInfo_in)
     { }
     
     forward_iterator_wrapper(const forward_iterator_wrapper& in)
-      :input_iterator_wrapper<T>(in)
+    : input_iterator_wrapper<T>(in)
     { }
 
     forward_iterator_wrapper()
@@ -311,16 +310,16 @@ namespace __gnu_test
    * instansiated directly, but generated from a test_container
    */
   template<class T>
-  struct bidirectional_iterator_wrapper:public forward_iterator_wrapper<T>
+  struct bidirectional_iterator_wrapper : public forward_iterator_wrapper<T>
   {
     typedef BoundsContainer<T> ContainerType;
     typedef std::bidirectional_iterator_tag iterator_category;
     bidirectional_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
-      :forward_iterator_wrapper<T>(_ptr, SharedInfo_in)
+    : forward_iterator_wrapper<T>(_ptr, SharedInfo_in)
     { }
 
     bidirectional_iterator_wrapper(const bidirectional_iterator_wrapper& in)
-      :forward_iterator_wrapper<T>(in)
+    : forward_iterator_wrapper<T>(in)
     { }
 
     bidirectional_iterator_wrapper(): forward_iterator_wrapper<T>()
@@ -375,16 +374,17 @@ namespace __gnu_test
    * instansiated directly, but generated from a test_container
    */
   template<class T>
-  struct random_access_iterator_wrapper:public bidirectional_iterator_wrapper<T>
+  struct random_access_iterator_wrapper 
+  : public bidirectional_iterator_wrapper<T>
   {
     typedef BoundsContainer<T> ContainerType;
     typedef std::random_access_iterator_tag iterator_category;
     random_access_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
-      : bidirectional_iterator_wrapper<T>(_ptr, SharedInfo_in)
+    : bidirectional_iterator_wrapper<T>(_ptr, SharedInfo_in)
     { }
 
     random_access_iterator_wrapper(const random_access_iterator_wrapper<T>& in)
-      : bidirectional_iterator_wrapper<T>(in)
+    : bidirectional_iterator_wrapper<T>(in)
     { }
 
     random_access_iterator_wrapper():bidirectional_iterator_wrapper<T>()