re PR libstdc++/31426 (TR1 includes do not work with -std=c++0x)

2007-05-31  Paolo Carlini  <pcarlini@suse.de>

	PR libstdc++/31426
	* include/bits/c++config: Remove namespace association bits
	from tr1 to std.

	* include/ext/type_traits.h (__promote, __promote2,
	__promote3, __promote4): Add.

	* include/bits/hashtable.h: New.
	* include/bits/functional_hash.h: Likewise.
	* include/tr1/hashtable.h: Likewise.

	* include/tr1_impl/random: New.
	* include/tr1_impl/cinttypes: Likewise.
	* include/tr1_impl/cstdlib: Likewise.
	* include/tr1_impl/unordered_map: Likewise.
	* include/tr1_impl/cstdio: Likewise.
	* include/tr1_impl/boost_shared_ptr.h: Likewise.
	* include/tr1_impl/cctype: Likewise.
	* include/tr1_impl/random.tcc: Likewise.
	* include/tr1_impl/tuple: Likewise.
	* include/tr1_impl/functional_hash.h: Likewise.
	* include/tr1_impl/hashtable: Likewise.
	* include/tr1_impl/cmath: Likewise.
	* include/tr1_impl/type_traitsfwd.h: Likewise.
	* include/tr1_impl/hashtable_policy.h: Likewise.
	* include/tr1_impl/cfenv: Likewise.
	* include/tr1_impl/unordered_set: Likewise.
	* include/tr1_impl/functional: Likewise.
	* include/tr1_impl/utility: Likewise.
	* include/tr1_impl/complex: Likewise.
	* include/tr1_impl/type_traits: Likewise.
	* include/tr1_impl/cwchar: Likewise.
	* include/tr1_impl/cstdint: Likewise.
	* include/tr1_impl/regex: Likewise.
	* include/tr1_impl/array: Likewise.
	* include/tr1_impl/cwctype: Likewise.

	* include/tr1/type_traitsfwd.h: Remove.
	* include/tr1/boost_shared_ptr.h: Likewise.
	* include/tr1/common.h: Likewise.
	* include/tr1/hashtable: Likewise.
	* include/tr1/hashtable_policy.h: Likewise.
	* include/tr1/random.tcc: Likewise.

	* include/c_global/cinttypes: Include tr1_impl/cinttypes.
	* include/c_global/cstdlib: Likewise for cstdlib.
	* include/c_global/cstdio: Likewise for cstdio.
	* include/c_global/cctype: Likewise for cctype.
	* include/c_global/cmath: Likewise for cmath.
	* include/c_global/cfenv: Likewise for cfenv.
	* include/c_global/cwchar: Likewise for cwchar.
	* include/c_global/cstdint: Likewise for cstdint.
	* include/c_global/cwctype: Likewise for cwctype.
	* include/tr1/cinttypes: Likewise for cinttypes.
	* include/tr1/cstdlib: Likewise for cstdlib.
	* include/tr1/cstdio: Likewise for cstdio.
	* include/tr1/cctype: Likewise for cctype.
	* include/tr1/cmath: Likewise for cmath.
	* include/tr1/cfenv: Likewise for cfenv.
	* include/tr1/cwchar: Likewise for cwchar.
	* include/tr1/cstdint: Likewise for cstdint.
	* include/tr1/cwctype: Likewise for cwctype.
	* include/tr1/functional_hash.h: Likewise for functional_hash.

	* include/std/tuple: Include tr1_impl/tuple.
	* include/std/utility: Likewise for utility.
	* include/std/type_traits: Likewise for type_traits.
	(is_pod): Just forward to __is_pod.
	(has_trivial_default_constructor): Just forward to
	__has_trivial_constructor.
	(has_trivial_copy_constructor): Just forward to __has_trivial_copy.
	(has_trivial_assign): Just forward to __has_trivial_assign.
	(has_trivial_destructor): Just forward to __has_trivial_destructor.
	(has_nothrow_default_constructor): Just forward to
	__has_nothrow_constructor.
	(has_nothrow_copy_constructor): Just forward to __has_nothrow_copy.
	(has_nothrow_assign): Just forward to __has_nothrow_assign.
	(is_base_of): Just forward to __is_base_of.
	(is_signed, is_unsigned): Implement according to the C++0x
	specifications.
	* include/std/memory: Likewise for memory.
	* include/std/regex: Likewise for regex.
	* include/std/random: Likewise for random.
	* include/std/unordered_map: Likewise for unordered_map.
	* include/std/unordered_set: Likewise for unordered_set.
	* include/std/functional: Likewise for functional.
	* include/std/complex: Likewise for complex.
	* include/std/array: Likewise for array.
	* include/tr1/tuple: Likewise for tuple.
	* include/tr1/utility: Likewise for utility.
	* include/tr1/type_traits: Likewise for type_traits
	* include/tr1/memory: Likewise for memory.
	* include/tr1/regex: Likewise for regex.
	* include/tr1/random: Likewise for random.
	* include/tr1/unordered_map: Likewise for unordered_map.
	* include/tr1/unordered_set: Likewise for unordered_set.
	* include/tr1/functional: Likewise for functional.
	* include/tr1/complex: Likewise for complex.
	* include/tr1/array: Likewise for array.

	* include/c_global/ctgmath: Tweak.
	* include/c_global/cstdarg: Likewise.
	* include/c_global/ctime: Likewise.
	* include/c_global/climits: Likewise.
	* include/c_global/cfloat: Likewise.	
	* include/c_global/ccomplex: Likewise.
	* include/c_global/cstdbool: Likewise.

	* include/tr1/poly_laguerre.tcc: Tweak, don't use _GLIBCXX_TR1.
	* include/tr1/riemann_zeta.tcc: Likewise.
	* include/tr1/beta_function.tcc: Likewise.
	* include/tr1/exp_integral.tcc: Likewise.
	* include/tr1/hypergeometric.tcc: Likewise.
	* include/tr1/modified_bessel_func.tcc: Likewise.
	* include/tr1/legendre_function.tcc: Likewise.
	* include/tr1/special_function_util.h: Likewise.
	* include/tr1/bessel_function.tcc: Likewise.
	* include/tr1/poly_hermite.tcc: Likewise.
	* include/tr1/ell_integral.tcc: Likewise.
	* include/tr1/gamma.tcc: Likewise.
	* include/tr1/stdlib.h: Likewise.
	* include/tr1/math.h: Likewise.

	* include/tr1/complex.h: Minor tweaks.
	* include/tr1/wctype.h: Likewise.
	* include/tr1/wchar.h: Likewise.
	* include/tr1/inttypes.h: Likewise.
	* include/tr1/tgmath.h: Likewise.
	* include/tr1/cstdbool: Likewise.
	* include/tr1/cfloat: Likewise.
	* include/tr1/ccomplex: Likewise.
	* include/tr1/ctime: Likewise.
	* include/tr1/climits: Likewise.
	* include/tr1/ctgmath: Likewise.
	* include/tr1/cstdarg: Likewise.

	* testsuite/tr1/headers.cc: Move...
	* testsuite/tr1/headers/all.cc: ... here.
	* testsuite/tr1/using_namespace_std_tr1.cc: Move...
	* testsuite/tr1/headers/c++200x/using_namespace_std_tr1.cc: ... here.
	* testsuite/tr1/headers/using_namespace_std_tr1.cc ... here.
	* testsuite/tr1/headers/c++200x/using_namespace_std_tr1.cc: New.

	* testsuite/20_util/tuple/requirements/explicit_instantiation.cc:
	Adjust namespace.
	* testsuite/20_util/has_nothrow_copy_constructor/value.cc: Adjust to
	the C++0x requirements.
	* testsuite/20_util/has_nothrow_default_constructor/value.cc: Likewise.
	* testsuite/20_util/has_trivial_copy_constructor/value.cc: Likewise.
	* testsuite/20_util/has_trivial_default_constructor/value.cc: Likewise.

	* testsuite/20_util/make_signed/requirements/typedefs_neg.cc: Adjust
	dg-error lines.
	* testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc:
	Likewise.
	* testsuite/20_util/headers/type_traits/types_std_c++0x_neg.cc:
	Un-xfail.

	* testsuite/20_util/is_signed/value.cc: New.
	* testsuite/20_util/is_signed/requirements/typedefs.cc: Likewise.
	* testsuite/20_util/is_signed/requirements/explicit_instantiation.cc:
	Likewise.
	* testsuite/20_util/is_unsigned/value.cc: Likewise..
	* testsuite/20_util/is_unsigned/requirements/typedefs.cc: Likewise.
	* testsuite/20_util/is_unsigned/requirements/explicit_instantiation.cc:
	Likewise.

	* include/Makefile.am: Adjust.	
	* include/Makefile.in: Regenerate.

From-SVN: r125244

125 files changed, 13158 insertions, 10952 deletions

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index 4259ef3..48d6f87 100644
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,5 +1,177 @@
 2007-05-31  Paolo Carlini  <pcarlini@suse.de>
 
+	PR libstdc++/31426
+	* include/bits/c++config: Remove namespace association bits
+	from tr1 to std.
+
+	* include/ext/type_traits.h (__promote, __promote2,
+	__promote3, __promote4): Add.
+
+	* include/bits/hashtable.h: New.
+	* include/bits/functional_hash.h: Likewise.
+	* include/tr1/hashtable.h: Likewise.
+
+	* include/tr1_impl/random: New.
+	* include/tr1_impl/cinttypes: Likewise.
+	* include/tr1_impl/cstdlib: Likewise.
+	* include/tr1_impl/unordered_map: Likewise.
+	* include/tr1_impl/cstdio: Likewise.
+	* include/tr1_impl/boost_shared_ptr.h: Likewise.
+	* include/tr1_impl/cctype: Likewise.
+	* include/tr1_impl/random.tcc: Likewise.
+	* include/tr1_impl/tuple: Likewise.
+	* include/tr1_impl/functional_hash.h: Likewise.
+	* include/tr1_impl/hashtable: Likewise.
+	* include/tr1_impl/cmath: Likewise.
+	* include/tr1_impl/type_traitsfwd.h: Likewise.
+	* include/tr1_impl/hashtable_policy.h: Likewise.
+	* include/tr1_impl/cfenv: Likewise.
+	* include/tr1_impl/unordered_set: Likewise.
+	* include/tr1_impl/functional: Likewise.
+	* include/tr1_impl/utility: Likewise.
+	* include/tr1_impl/complex: Likewise.
+	* include/tr1_impl/type_traits: Likewise.
+	* include/tr1_impl/cwchar: Likewise.
+	* include/tr1_impl/cstdint: Likewise.
+	* include/tr1_impl/regex: Likewise.
+	* include/tr1_impl/array: Likewise.
+	* include/tr1_impl/cwctype: Likewise.
+
+	* include/tr1/type_traitsfwd.h: Remove.
+	* include/tr1/boost_shared_ptr.h: Likewise.
+	* include/tr1/common.h: Likewise.
+	* include/tr1/hashtable: Likewise.
+	* include/tr1/hashtable_policy.h: Likewise.
+	* include/tr1/random.tcc: Likewise.
+
+	* include/c_global/cinttypes: Include tr1_impl/cinttypes.
+	* include/c_global/cstdlib: Likewise for cstdlib.
+	* include/c_global/cstdio: Likewise for cstdio.
+	* include/c_global/cctype: Likewise for cctype.
+	* include/c_global/cmath: Likewise for cmath.
+	* include/c_global/cfenv: Likewise for cfenv.
+	* include/c_global/cwchar: Likewise for cwchar.
+	* include/c_global/cstdint: Likewise for cstdint.
+	* include/c_global/cwctype: Likewise for cwctype.
+	* include/tr1/cinttypes: Likewise for cinttypes.
+	* include/tr1/cstdlib: Likewise for cstdlib.
+	* include/tr1/cstdio: Likewise for cstdio.
+	* include/tr1/cctype: Likewise for cctype.
+	* include/tr1/cmath: Likewise for cmath.
+	* include/tr1/cfenv: Likewise for cfenv.
+	* include/tr1/cwchar: Likewise for cwchar.
+	* include/tr1/cstdint: Likewise for cstdint.
+	* include/tr1/cwctype: Likewise for cwctype.
+	* include/tr1/functional_hash.h: Likewise for functional_hash.
+
+	* include/std/tuple: Include tr1_impl/tuple.
+	* include/std/utility: Likewise for utility.
+	* include/std/type_traits: Likewise for type_traits.
+	(is_pod): Just forward to __is_pod.
+	(has_trivial_default_constructor): Just forward to
+	__has_trivial_constructor.
+	(has_trivial_copy_constructor): Just forward to __has_trivial_copy.
+	(has_trivial_assign): Just forward to __has_trivial_assign.
+	(has_trivial_destructor): Just forward to __has_trivial_destructor.
+	(has_nothrow_default_constructor): Just forward to
+	__has_nothrow_constructor.
+	(has_nothrow_copy_constructor): Just forward to __has_nothrow_copy.
+	(has_nothrow_assign): Just forward to __has_nothrow_assign.
+	(is_base_of): Just forward to __is_base_of.
+	(is_signed, is_unsigned): Implement according to the C++0x
+	specifications.
+	* include/std/memory: Likewise for memory.
+	* include/std/regex: Likewise for regex.
+	* include/std/random: Likewise for random.
+	* include/std/unordered_map: Likewise for unordered_map.
+	* include/std/unordered_set: Likewise for unordered_set.
+	* include/std/functional: Likewise for functional.
+	* include/std/complex: Likewise for complex.
+	* include/std/array: Likewise for array.
+	* include/tr1/tuple: Likewise for tuple.
+	* include/tr1/utility: Likewise for utility.
+	* include/tr1/type_traits: Likewise for type_traits
+	* include/tr1/memory: Likewise for memory.
+	* include/tr1/regex: Likewise for regex.
+	* include/tr1/random: Likewise for random.
+	* include/tr1/unordered_map: Likewise for unordered_map.
+	* include/tr1/unordered_set: Likewise for unordered_set.
+	* include/tr1/functional: Likewise for functional.
+	* include/tr1/complex: Likewise for complex.
+	* include/tr1/array: Likewise for array.
+
+	* include/c_global/ctgmath: Tweak.
+	* include/c_global/cstdarg: Likewise.
+	* include/c_global/ctime: Likewise.
+	* include/c_global/climits: Likewise.
+	* include/c_global/cfloat: Likewise.	
+	* include/c_global/ccomplex: Likewise.
+	* include/c_global/cstdbool: Likewise.
+
+	* include/tr1/poly_laguerre.tcc: Tweak, don't use _GLIBCXX_TR1.
+	* include/tr1/riemann_zeta.tcc: Likewise.
+	* include/tr1/beta_function.tcc: Likewise.
+	* include/tr1/exp_integral.tcc: Likewise.
+	* include/tr1/hypergeometric.tcc: Likewise.
+	* include/tr1/modified_bessel_func.tcc: Likewise.
+	* include/tr1/legendre_function.tcc: Likewise.
+	* include/tr1/special_function_util.h: Likewise.
+	* include/tr1/bessel_function.tcc: Likewise.
+	* include/tr1/poly_hermite.tcc: Likewise.
+	* include/tr1/ell_integral.tcc: Likewise.
+	* include/tr1/gamma.tcc: Likewise.
+	* include/tr1/stdlib.h: Likewise.
+	* include/tr1/math.h: Likewise.
+
+	* include/tr1/complex.h: Minor tweaks.
+	* include/tr1/wctype.h: Likewise.
+	* include/tr1/wchar.h: Likewise.
+	* include/tr1/inttypes.h: Likewise.
+	* include/tr1/tgmath.h: Likewise.
+	* include/tr1/cstdbool: Likewise.
+	* include/tr1/cfloat: Likewise.
+	* include/tr1/ccomplex: Likewise.
+	* include/tr1/ctime: Likewise.
+	* include/tr1/climits: Likewise.
+	* include/tr1/ctgmath: Likewise.
+	* include/tr1/cstdarg: Likewise.
+
+	* testsuite/tr1/headers.cc: Move...
+	* testsuite/tr1/headers/all.cc: ... here.
+	* testsuite/tr1/using_namespace_std_tr1.cc: Move...
+	* testsuite/tr1/headers/c++200x/using_namespace_std_tr1.cc: ... here.
+	* testsuite/tr1/headers/using_namespace_std_tr1.cc ... here.
+	* testsuite/tr1/headers/c++200x/using_namespace_std_tr1.cc: New.
+
+	* testsuite/20_util/tuple/requirements/explicit_instantiation.cc:
+	Adjust namespace.
+	* testsuite/20_util/has_nothrow_copy_constructor/value.cc: Adjust to
+	the C++0x requirements.
+	* testsuite/20_util/has_nothrow_default_constructor/value.cc: Likewise.
+	* testsuite/20_util/has_trivial_copy_constructor/value.cc: Likewise.
+	* testsuite/20_util/has_trivial_default_constructor/value.cc: Likewise.
+
+	* testsuite/20_util/make_signed/requirements/typedefs_neg.cc: Adjust
+	dg-error lines.
+	* testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc:
+	Likewise.
+	* testsuite/20_util/headers/type_traits/types_std_c++0x_neg.cc:
+	Un-xfail.
+
+	* testsuite/20_util/is_signed/value.cc: New.
+	* testsuite/20_util/is_signed/requirements/typedefs.cc: Likewise.
+	* testsuite/20_util/is_signed/requirements/explicit_instantiation.cc:
+	Likewise.
+	* testsuite/20_util/is_unsigned/value.cc: Likewise..
+	* testsuite/20_util/is_unsigned/requirements/typedefs.cc: Likewise.
+	* testsuite/20_util/is_unsigned/requirements/explicit_instantiation.cc:
+	Likewise.
+
+	* include/Makefile.am: Adjust.	
+	* include/Makefile.in: Regenerate.
+
+2007-05-31  Paolo Carlini  <pcarlini@suse.de>
+
 	PR c++/32158 (libstdc++ bits)
 	* include/bits/stl_uninitialized.h (__uninitialized_copy_aux,
 	__uninitialized_fill_aux, __uninitialized_fill_n_aux):
diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am
index cfa995e..406b313 100644
--- a/libstdc++-v3/include/Makefile.am
+++ b/libstdc++-v3/include/Makefile.am
@@ -82,8 +82,10 @@ bits_headers = \
 	${bits_srcdir}/deque.tcc \
 	${bits_srcdir}/fstream.tcc \
 	${bits_srcdir}/functexcept.h \
+	${bits_srcdir}/functional_hash.h \
 	${bits_srcdir}/gslice.h \
 	${bits_srcdir}/gslice_array.h \
+	${bits_srcdir}/hashtable.h \
 	${bits_srcdir}/indirect_array.h \
 	${bits_srcdir}/ios_base.h \
 	${bits_srcdir}/istream.tcc \
@@ -540,7 +542,6 @@ tr1_headers = \
 	${tr1_srcdir}/array \
 	${tr1_srcdir}/bessel_function.tcc \
 	${tr1_srcdir}/beta_function.tcc \
-	${tr1_srcdir}/boost_shared_ptr.h \
 	${tr1_srcdir}/ccomplex \
 	${tr1_srcdir}/cctype \
 	${tr1_srcdir}/cfenv \
@@ -548,7 +549,6 @@ tr1_headers = \
 	${tr1_srcdir}/cinttypes \
 	${tr1_srcdir}/climits \
 	${tr1_srcdir}/cmath \
-	${tr1_srcdir}/common.h \
 	${tr1_srcdir}/complex \
 	${tr1_srcdir}/complex.h \
 	${tr1_srcdir}/cstdarg \
@@ -568,9 +568,8 @@ tr1_headers = \
 	${tr1_srcdir}/functional \
 	${tr1_srcdir}/functional_hash.h \
 	${tr1_srcdir}/gamma.tcc \
-	${tr1_srcdir}/hashtable \
 	${tr1_srcdir}/hypergeometric.tcc \
-	${tr1_srcdir}/hashtable_policy.h \
+	${tr1_srcdir}/hashtable.h \
 	${tr1_srcdir}/inttypes.h \
 	${tr1_srcdir}/limits.h \
 	${tr1_srcdir}/math.h \
@@ -580,7 +579,6 @@ tr1_headers = \
 	${tr1_srcdir}/poly_laguerre.tcc \
 	${tr1_srcdir}/legendre_function.tcc \
 	${tr1_srcdir}/random \
-	${tr1_srcdir}/random.tcc \
 	${tr1_srcdir}/regex \
 	${tr1_srcdir}/riemann_zeta.tcc \
 	${tr1_srcdir}/special_function_util.h \
@@ -592,7 +590,6 @@ tr1_headers = \
 	${tr1_srcdir}/tgmath.h \
 	${tr1_srcdir}/tuple \
 	${tr1_srcdir}/type_traits \
-	${tr1_srcdir}/type_traitsfwd.h \
 	${tr1_srcdir}/unordered_set \
 	${tr1_srcdir}/unordered_map \
 	${tr1_srcdir}/utility \
@@ -600,6 +597,36 @@ tr1_headers = \
 	${tr1_srcdir}/wctype.h
 
 
+tr1_impl_srcdir = ${glibcxx_srcdir}/include/tr1_impl
+tr1_impl_builddir = ./tr1_impl
+tr1_impl_headers = \
+	${tr1_impl_srcdir}/array \
+	${tr1_impl_srcdir}/boost_shared_ptr.h \
+	${tr1_impl_srcdir}/cctype \
+	${tr1_impl_srcdir}/cfenv \
+	${tr1_impl_srcdir}/cinttypes \
+	${tr1_impl_srcdir}/cmath \
+	${tr1_impl_srcdir}/complex \
+	${tr1_impl_srcdir}/cstdint \
+	${tr1_impl_srcdir}/cstdio \
+	${tr1_impl_srcdir}/cstdlib \
+	${tr1_impl_srcdir}/cwchar \
+	${tr1_impl_srcdir}/cwctype \
+	${tr1_impl_srcdir}/functional \
+	${tr1_impl_srcdir}/functional_hash.h \
+	${tr1_impl_srcdir}/hashtable \
+	${tr1_impl_srcdir}/hashtable_policy.h \
+	${tr1_impl_srcdir}/random \
+	${tr1_impl_srcdir}/random.tcc \
+	${tr1_impl_srcdir}/regex \
+	${tr1_impl_srcdir}/tuple \
+	${tr1_impl_srcdir}/type_traits \
+	${tr1_impl_srcdir}/type_traitsfwd.h \
+	${tr1_impl_srcdir}/unordered_map \
+	${tr1_impl_srcdir}/unordered_set \
+	${tr1_impl_srcdir}/utility
+
+
 # This is the common subset of C++ files that all three "C" header models use.
 c_base_srcdir = $(C_INCLUDE_DIR)
 c_base_builddir = .
@@ -793,7 +820,7 @@ endif
 allstamped = \
 	stamp-std stamp-bits stamp-c_base stamp-c_base_extra \
 	stamp-c_compatibility  stamp-backward stamp-ext stamp-pb \
-	stamp-tr1 stamp-debug stamp-host
+	stamp-tr1 stamp-tr1-impl stamp-debug stamp-host
 
 # List of all files that are created by explicit building, editing, or
 # catenation.
@@ -932,6 +959,15 @@ stamp-tr1: ${tr1_headers}
 	fi ;\
 	$(STAMP) stamp-tr1
 
+stamp-tr1-impl: ${tr1_impl_headers}
+	@if [ ! -d "${tr1_impl_builddir}" ]; then \
+	    mkdir -p ${tr1_impl_builddir} ;\
+	fi ;\
+	if [ ! -f stamp-tr1-impl ]; then \
+	  (cd ${tr1_impl_builddir} && $(LN_S) $? . || true) ;\
+	fi ;\
+	$(STAMP) stamp-tr1-impl
+
 stamp-debug: ${debug_headers}
 	@if [ ! -d "${debug_builddir}" ]; then \
 	  mkdir -p ${debug_builddir} ;\
@@ -1158,6 +1194,9 @@ install-headers:
 	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${tr1_builddir}
 	for file in ${tr1_headers}; do \
 	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${tr1_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${tr1_impl_builddir}
+	for file in ${tr1_impl_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${tr1_impl_builddir}; done
 	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${c_base_builddir}
 	for file in ${c_base_headers}; do \
 	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${c_base_builddir}; done
@@ -1200,8 +1239,10 @@ clean-local:
 # developer tries to create them via make in the include build
 # directory. (This is more of an example of how this kind of rule can
 # be made.)
-.PRECIOUS: $(std_headers) $(c_base_headers) $(tr1_headers) $(ext_headers)
+.PRECIOUS: $(std_headers) $(c_base_headers) $(tr1_headers) $(tr1_impl_headers)
+	   $(ext_headers)
 $(std_headers): ; @:
 $(c_base_headers): ; @:
 $(tr1_headers): ; @:
+$(tr1_impl_headers): ; @:
 $(ext_headers): ; @:
diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in
index 5a807a0..bffba8d 100644
--- a/libstdc++-v3/include/Makefile.in
+++ b/libstdc++-v3/include/Makefile.in
@@ -327,8 +327,10 @@ bits_headers = \
 	${bits_srcdir}/deque.tcc \
 	${bits_srcdir}/fstream.tcc \
 	${bits_srcdir}/functexcept.h \
+	${bits_srcdir}/functional_hash.h \
 	${bits_srcdir}/gslice.h \
 	${bits_srcdir}/gslice_array.h \
+	${bits_srcdir}/hashtable.h \
 	${bits_srcdir}/indirect_array.h \
 	${bits_srcdir}/ios_base.h \
 	${bits_srcdir}/istream.tcc \
@@ -781,7 +783,6 @@ tr1_headers = \
 	${tr1_srcdir}/array \
 	${tr1_srcdir}/bessel_function.tcc \
 	${tr1_srcdir}/beta_function.tcc \
-	${tr1_srcdir}/boost_shared_ptr.h \
 	${tr1_srcdir}/ccomplex \
 	${tr1_srcdir}/cctype \
 	${tr1_srcdir}/cfenv \
@@ -789,7 +790,6 @@ tr1_headers = \
 	${tr1_srcdir}/cinttypes \
 	${tr1_srcdir}/climits \
 	${tr1_srcdir}/cmath \
-	${tr1_srcdir}/common.h \
 	${tr1_srcdir}/complex \
 	${tr1_srcdir}/complex.h \
 	${tr1_srcdir}/cstdarg \
@@ -809,9 +809,8 @@ tr1_headers = \
 	${tr1_srcdir}/functional \
 	${tr1_srcdir}/functional_hash.h \
 	${tr1_srcdir}/gamma.tcc \
-	${tr1_srcdir}/hashtable \
 	${tr1_srcdir}/hypergeometric.tcc \
-	${tr1_srcdir}/hashtable_policy.h \
+	${tr1_srcdir}/hashtable.h \
 	${tr1_srcdir}/inttypes.h \
 	${tr1_srcdir}/limits.h \
 	${tr1_srcdir}/math.h \
@@ -821,7 +820,6 @@ tr1_headers = \
 	${tr1_srcdir}/poly_laguerre.tcc \
 	${tr1_srcdir}/legendre_function.tcc \
 	${tr1_srcdir}/random \
-	${tr1_srcdir}/random.tcc \
 	${tr1_srcdir}/regex \
 	${tr1_srcdir}/riemann_zeta.tcc \
 	${tr1_srcdir}/special_function_util.h \
@@ -833,13 +831,41 @@ tr1_headers = \
 	${tr1_srcdir}/tgmath.h \
 	${tr1_srcdir}/tuple \
 	${tr1_srcdir}/type_traits \
-	${tr1_srcdir}/type_traitsfwd.h \
 	${tr1_srcdir}/unordered_set \
 	${tr1_srcdir}/unordered_map \
 	${tr1_srcdir}/utility \
 	${tr1_srcdir}/wchar.h \
 	${tr1_srcdir}/wctype.h
 
+tr1_impl_srcdir = ${glibcxx_srcdir}/include/tr1_impl
+tr1_impl_builddir = ./tr1_impl
+tr1_impl_headers = \
+	${tr1_impl_srcdir}/array \
+	${tr1_impl_srcdir}/boost_shared_ptr.h \
+	${tr1_impl_srcdir}/cctype \
+	${tr1_impl_srcdir}/cfenv \
+	${tr1_impl_srcdir}/cinttypes \
+	${tr1_impl_srcdir}/cmath \
+	${tr1_impl_srcdir}/complex \
+	${tr1_impl_srcdir}/cstdint \
+	${tr1_impl_srcdir}/cstdio \
+	${tr1_impl_srcdir}/cstdlib \
+	${tr1_impl_srcdir}/cwchar \
+	${tr1_impl_srcdir}/cwctype \
+	${tr1_impl_srcdir}/functional \
+	${tr1_impl_srcdir}/functional_hash.h \
+	${tr1_impl_srcdir}/hashtable \
+	${tr1_impl_srcdir}/hashtable_policy.h \
+	${tr1_impl_srcdir}/random \
+	${tr1_impl_srcdir}/random.tcc \
+	${tr1_impl_srcdir}/regex \
+	${tr1_impl_srcdir}/tuple \
+	${tr1_impl_srcdir}/type_traits \
+	${tr1_impl_srcdir}/type_traitsfwd.h \
+	${tr1_impl_srcdir}/unordered_map \
+	${tr1_impl_srcdir}/unordered_set \
+	${tr1_impl_srcdir}/utility
+
 
 # This is the common subset of C++ files that all three "C" header models use.
 c_base_srcdir = $(C_INCLUDE_DIR)
@@ -1017,7 +1043,7 @@ PCHFLAGS = -Winvalid-pch -Wno-deprecated -x c++-header $(CXXFLAGS)
 allstamped = \
 	stamp-std stamp-bits stamp-c_base stamp-c_base_extra \
 	stamp-c_compatibility  stamp-backward stamp-ext stamp-pb \
-	stamp-tr1 stamp-debug stamp-host
+	stamp-tr1 stamp-tr1-impl stamp-debug stamp-host
 
 
 # List of all files that are created by explicit building, editing, or
@@ -1326,6 +1352,15 @@ stamp-tr1: ${tr1_headers}
 	fi ;\
 	$(STAMP) stamp-tr1
 
+stamp-tr1-impl: ${tr1_impl_headers}
+	@if [ ! -d "${tr1_impl_builddir}" ]; then \
+	    mkdir -p ${tr1_impl_builddir} ;\
+	fi ;\
+	if [ ! -f stamp-tr1-impl ]; then \
+	  (cd ${tr1_impl_builddir} && $(LN_S) $? . || true) ;\
+	fi ;\
+	$(STAMP) stamp-tr1-impl
+
 stamp-debug: ${debug_headers}
 	@if [ ! -d "${debug_builddir}" ]; then \
 	  mkdir -p ${debug_builddir} ;\
@@ -1540,6 +1575,9 @@ install-headers:
 	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${tr1_builddir}
 	for file in ${tr1_headers}; do \
 	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${tr1_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${tr1_impl_builddir}
+	for file in ${tr1_impl_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${tr1_impl_builddir}; done
 	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${c_base_builddir}
 	for file in ${c_base_headers}; do \
 	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${c_base_builddir}; done
@@ -1579,10 +1617,12 @@ clean-local:
 # developer tries to create them via make in the include build
 # directory. (This is more of an example of how this kind of rule can
 # be made.)
-.PRECIOUS: $(std_headers) $(c_base_headers) $(tr1_headers) $(ext_headers)
+.PRECIOUS: $(std_headers) $(c_base_headers) $(tr1_headers) $(tr1_impl_headers)
+	   $(ext_headers)
 $(std_headers): ; @:
 $(c_base_headers): ; @:
 $(tr1_headers): ; @:
+$(tr1_impl_headers): ; @:
 $(ext_headers): ; @:
 # Tell versions [3.59,3.63) of GNU make to not export all variables.
 # Otherwise a system limit (for SysV at least) may be exceeded.
diff --git a/libstdc++-v3/include/bits/c++config b/libstdc++-v3/include/bits/c++config
index f4e951c..a519018 100644
--- a/libstdc++-v3/include/bits/c++config
+++ b/libstdc++-v3/include/bits/c++config
@@ -71,10 +71,6 @@
 # define _GLIBCXX_NAMESPACE_ASSOCIATION_DEBUG 1
 #endif
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# define _GLIBCXX_NAMESPACE_ASSOCIATION_CXX0X 1
-#endif
-
 #define _GLIBCXX_NAMESPACE_ASSOCIATION_VERSION 
 
 // Macros for namespace scope.
@@ -155,18 +151,6 @@ namespace __gnu_cxx
 #endif
 #endif
 
-// Namespace associations for C++0x, TR1 in std.
-#if _GLIBCXX_NAMESPACE_ASSOCIATION_CXX0X
-namespace std
-{ 
-  namespace __cxx200x { }
-  using namespace __cxx200x __attribute__ ((strong)); 
-}
-# define _GLIBCXX_TR1 __cxx200x
-#else
-# define _GLIBCXX_TR1 tr1
-#endif
-
 // Define if compatibility should be provided for -mlong-double-64.
 #undef _GLIBCXX_LONG_DOUBLE_COMPAT
 
diff --git a/libstdc++-v3/include/bits/functional_hash.h b/libstdc++-v3/include/bits/functional_hash.h
new file mode 100644
index 0000000..022c5ca
--- /dev/null
+++ b/libstdc++-v3/include/bits/functional_hash.h
@@ -0,0 +1,63 @@
+// functional_hash.h header -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+// Boston, MA 02110-1301, USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file functional_hash.h
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+#ifndef _FUNCTIONAL_HASH_H
+#define _FUNCTIONAL_HASH_H 1
+
+#pragma GCC system_header
+
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
+# include <c++0x_warning.h>
+#endif
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  error C++0x header cannot be included from TR1 header
+#endif
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  include <tr1_impl/functional_hash.h>
+#else
+#  define _GLIBCXX_INCLUDE_AS_CXX0X
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  define _GLIBCXX_END_NAMESPACE_TR1
+#  define _GLIBCXX_TR1
+#  include <tr1_impl/functional_hash.h>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
+
+#endif // _FUNCTIONAL_HASH_H
+
diff --git a/libstdc++-v3/include/bits/hashtable.h b/libstdc++-v3/include/bits/hashtable.h
new file mode 100644
index 0000000..d1da5fdd
--- /dev/null
+++ b/libstdc++-v3/include/bits/hashtable.h
@@ -0,0 +1,63 @@
+// hashtable.h header -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+// Boston, MA 02110-1301, USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file hashtable.h
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+#ifndef _HASHTABLE_H
+#define _HASHTABLE_H 1
+
+#pragma GCC system_header
+
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
+# include <c++0x_warning.h>
+#endif
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  error C++0x header cannot be included from TR1 header
+#endif
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  include <tr1_impl/hashtable>
+#else
+#  define _GLIBCXX_INCLUDE_AS_CXX0X
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  define _GLIBCXX_END_NAMESPACE_TR1
+#  define _GLIBCXX_TR1
+#  include <tr1_impl/hashtable>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
+
+#endif // _HASHTABLE_H
+
diff --git a/libstdc++-v3/include/c_global/ccomplex b/libstdc++-v3/include/c_global/ccomplex
index 1d08038..bd37e22 100644
--- a/libstdc++-v3/include/c_global/ccomplex
+++ b/libstdc++-v3/include/c_global/ccomplex
@@ -36,11 +36,14 @@
 #ifndef _GLIBCXX_CCOMPLEX
 #define _GLIBCXX_CCOMPLEX 1
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/ccomplex>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
 # include <c++0x_warning.h>
 #endif
 
-#endif 
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  error C++0x header cannot be included from TR1 header
+#endif
+
+#include <complex>
 
+#endif
diff --git a/libstdc++-v3/include/c_global/cctype b/libstdc++-v3/include/c_global/cctype
index 05436e4..440245e 100644
--- a/libstdc++-v3/include/c_global/cctype
+++ b/libstdc++-v3/include/c_global/cctype
@@ -1,6 +1,7 @@
 // -*- C++ -*- forwarding header.
 
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+// 2006, 2007
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -84,7 +85,22 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
 _GLIBCXX_END_NAMESPACE
 
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cctype>
+#  if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#    error C++0x header cannot be included from TR1 header
+#  endif
+#  if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#    include <tr1_impl/cctype>
+#  else
+#    define _GLIBCXX_INCLUDE_AS_CXX0X
+#    define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    define _GLIBCXX_END_NAMESPACE_TR1
+#    define _GLIBCXX_TR1
+#    include <tr1_impl/cctype>
+#    undef _GLIBCXX_TR1
+#    undef _GLIBCXX_END_NAMESPACE_TR1
+#    undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    undef _GLIBCXX_INCLUDE_AS_CXX0X
+#  endif
 #endif
 
 #endif
diff --git a/libstdc++-v3/include/c_global/cfenv b/libstdc++-v3/include/c_global/cfenv
index f11c531..de72ed4 100644
--- a/libstdc++-v3/include/c_global/cfenv
+++ b/libstdc++-v3/include/c_global/cfenv
@@ -36,11 +36,28 @@
 #ifndef _GLIBCXX_CFENV
 #define _GLIBCXX_CFENV 1
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cfenv>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
 # include <c++0x_warning.h>
 #endif
 
-#endif 
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  error C++0x header cannot be included from TR1 header
+#endif
+
+#include <bits/c++config.h>
 
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  include <tr1_impl/cfenv>
+#else
+#  define _GLIBCXX_INCLUDE_AS_CXX0X
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  define _GLIBCXX_END_NAMESPACE_TR1
+#  define _GLIBCXX_TR1
+#  include <tr1_impl/cfenv>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
+
+#endif
diff --git a/libstdc++-v3/include/c_global/cfloat b/libstdc++-v3/include/c_global/cfloat
index 9d8c039..a3edc2a 100644
--- a/libstdc++-v3/include/c_global/cfloat
+++ b/libstdc++-v3/include/c_global/cfloat
@@ -50,7 +50,15 @@
 #define _GLIBCXX_CFLOAT 1
 
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cfloat>
+#  if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#    error C++0x header cannot be included from TR1 header
+#  endif
+#  ifndef DECIMAL_DIG
+#    define DECIMAL_DIG __DECIMAL_DIG__
+#  endif
+#  ifndef FLT_EVAL_METHOD
+#    define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
+#  endif
 #endif
 
 #endif
diff --git a/libstdc++-v3/include/c_global/cinttypes b/libstdc++-v3/include/c_global/cinttypes
index d42c7a3..8caceaf 100644
--- a/libstdc++-v3/include/c_global/cinttypes
+++ b/libstdc++-v3/include/c_global/cinttypes
@@ -36,11 +36,28 @@
 #ifndef _GLIBCXX_CINTTYPES
 #define _GLIBCXX_CINTTYPES 1
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cinttypes>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
 # include <c++0x_warning.h>
 #endif
 
-#endif 
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  error C++0x header cannot be included from TR1 header
+#endif
+
+#include <cstdint>
 
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  include <tr1_impl/cinttypes>
+#else
+#  define _GLIBCXX_INCLUDE_AS_CXX0X
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  define _GLIBCXX_END_NAMESPACE_TR1
+#  define _GLIBCXX_TR1
+#  include <tr1_impl/cinttypes>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
+
+#endif
diff --git a/libstdc++-v3/include/c_global/climits b/libstdc++-v3/include/c_global/climits
index 396bbcb..910c80a 100644
--- a/libstdc++-v3/include/c_global/climits
+++ b/libstdc++-v3/include/c_global/climits
@@ -1,6 +1,7 @@
 // -*- C++ -*- forwarding header.
 
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+// 2006, 2007
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -49,8 +50,16 @@
 #ifndef _GLIBCXX_CLIMITS
 #define _GLIBCXX_CLIMITS 1
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/climits>
+#ifndef LLONG_MIN
+#define LLONG_MIN -__LONG_LONG_MAX__ - 1
+#endif
+
+#ifndef LLONG_MAX
+#define LLONG_MAX __LONG_LONG_MAX__
+#endif
+
+#ifndef ULLONG_MAX
+#define ULLONG_MAX __LONG_LONG_MAX__ * 2ULL + 1
 #endif
 
 #endif
diff --git a/libstdc++-v3/include/c_global/cmath b/libstdc++-v3/include/c_global/cmath
index ab21c9a..dde0154 100644
--- a/libstdc++-v3/include/c_global/cmath
+++ b/libstdc++-v3/include/c_global/cmath
@@ -1,6 +1,7 @@
 // -*- C++ -*- C forwarding header.
 
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+// 2006, 2007
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -82,7 +83,17 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
 
   // Forward declaration of a helper function.  This really should be
   // an `exported' forward declaration.
-  template<typename _Tp> _Tp __cmath_power(_Tp, unsigned int);
+  template<typename _Tp>
+    _Tp __cmath_power(_Tp, unsigned int);
+
+  template<typename _Tp>
+    inline _Tp
+    __pow_helper(_Tp __x, int __n)
+    {
+      return __n < 0
+        ? _Tp(1)/__cmath_power(__x, -__n)
+        : __cmath_power(__x, __n);
+    }
 
   inline double
   abs(double __x)
@@ -123,8 +134,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
   { return __builtin_asinl(__x); }
 
   template<typename _Tp>
-  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-					 double>::__type
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+					   double>::__type
     asin(_Tp __x)
     { return __builtin_asin(__x); }
 
@@ -139,8 +150,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
   { return __builtin_atanl(__x); }
 
   template<typename _Tp>
-  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
-					 double>::__type
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
     atan(_Tp __x)
     { return __builtin_atan(__x); }
 
@@ -155,11 +166,12 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
   { return __builtin_atan2l(__y, __x); }
 
   template<typename _Tp, typename _Up>
-    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value
-    					   && __is_integer<_Up>::__value, 
-					   double>::__type
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
     atan2(_Tp __y, _Up __x)
-    { return __builtin_atan2(__y, __x); }
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return atan2(__type(__y), __type(__x));
+    }
 
   using ::ceil;
 
@@ -341,15 +353,6 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
   modf(long double __x, long double* __iptr)
   { return __builtin_modfl(__x, __iptr); }
 
-  template<typename _Tp>
-    inline _Tp
-    __pow_helper(_Tp __x, int __n)
-    {
-      return __n < 0
-        ? _Tp(1)/__cmath_power(__x, -__n)
-        : __cmath_power(__x, __n);
-    }
-
   using ::pow;
 
   inline float
@@ -360,6 +363,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
   pow(long double __x, long double __y)
   { return __builtin_powl(__x, __y); }
 
+  // DR 550.
   inline double
   pow(double __x, int __i)
   { return __builtin_powi(__x, __i); }
@@ -372,6 +376,14 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
   pow(long double __x, int __n)
   { return __builtin_powil(__x, __n); }
 
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    pow(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return pow(__type(__x), __type(__y));
+    }
+
   using ::sin;
 
   inline float
@@ -597,7 +609,23 @@ _GLIBCXX_END_NAMESPACE
 #endif
 
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cmath>
+#  if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#    error C++0x header cannot be included from TR1 header
+#  endif
+#  include <type_traits>
+#  if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#    include <tr1_impl/cmath>
+#  else
+#    define _GLIBCXX_INCLUDE_AS_CXX0X
+#    define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    define _GLIBCXX_END_NAMESPACE_TR1
+#    define _GLIBCXX_TR1
+#    include <tr1_impl/cmath>
+#    undef _GLIBCXX_TR1
+#    undef _GLIBCXX_END_NAMESPACE_TR1
+#    undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    undef _GLIBCXX_INCLUDE_AS_CXX0X
+#  endif
 #endif
 
 #endif
diff --git a/libstdc++-v3/include/c_global/cstdarg b/libstdc++-v3/include/c_global/cstdarg
index 9acd24e..21b4f7a 100644
--- a/libstdc++-v3/include/c_global/cstdarg
+++ b/libstdc++-v3/include/c_global/cstdarg
@@ -61,8 +61,4 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
 
 _GLIBCXX_END_NAMESPACE
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cstdarg>
-#endif
-
 #endif
diff --git a/libstdc++-v3/include/c_global/cstdbool b/libstdc++-v3/include/c_global/cstdbool
index ac18c74..28dfa76 100644
--- a/libstdc++-v3/include/c_global/cstdbool
+++ b/libstdc++-v3/include/c_global/cstdbool
@@ -36,10 +36,13 @@
 #ifndef _GLIBCXX_CSTDBOOL
 #define _GLIBCXX_CSTDBOOL 1
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cstdbool>
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
+#  include <c++0x_warning.h>
 #else
-# include <c++0x_warning.h>
+#  include <bits/c++config.h>
+#  if _GLIBCXX_HAVE_STDBOOL_H
+#    include_next <stdbool.h>
+#  endif
 #endif
 
 #endif 
diff --git a/libstdc++-v3/include/c_global/cstdint b/libstdc++-v3/include/c_global/cstdint
index ece67a3..6c3f438 100644
--- a/libstdc++-v3/include/c_global/cstdint
+++ b/libstdc++-v3/include/c_global/cstdint
@@ -36,11 +36,28 @@
 #ifndef _GLIBCXX_CSTDINT
 #define _GLIBCXX_CSTDINT 1
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cstdint>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
 # include <c++0x_warning.h>
 #endif
 
-#endif 
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  error C++0x header cannot be included from TR1 header
+#endif
+
+#include <bits/c++config.h>
 
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  include <tr1_impl/cstdint>
+#else
+#  define _GLIBCXX_INCLUDE_AS_CXX0X
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  define _GLIBCXX_END_NAMESPACE_TR1
+#  define _GLIBCXX_TR1
+#  include <tr1_impl/cstdint>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
+
+#endif
diff --git a/libstdc++-v3/include/c_global/cstdio b/libstdc++-v3/include/c_global/cstdio
index ec25b99..3cdb5d6 100644
--- a/libstdc++-v3/include/c_global/cstdio
+++ b/libstdc++-v3/include/c_global/cstdio
@@ -1,6 +1,7 @@
 // -*- C++ -*- forwarding header.
 
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+// 2006, 2007
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -188,7 +189,22 @@ _GLIBCXX_END_NAMESPACE
 #endif // _GLIBCXX_USE_C99
 
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cstdio>
+#  if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#    error C++0x header cannot be included from TR1 header
+#  endif
+#  if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#    include <tr1_impl/cstdio>
+#  else
+#    define _GLIBCXX_INCLUDE_AS_CXX0X
+#    define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    define _GLIBCXX_END_NAMESPACE_TR1
+#    define _GLIBCXX_TR1
+#    include <tr1_impl/cstdio>
+#    undef _GLIBCXX_TR1
+#    undef _GLIBCXX_END_NAMESPACE_TR1
+#    undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    undef _GLIBCXX_INCLUDE_AS_CXX0X
+#  endif
 #endif
 
 #endif
diff --git a/libstdc++-v3/include/c_global/cstdlib b/libstdc++-v3/include/c_global/cstdlib
index e4ab8f9..3386ff0 100644
--- a/libstdc++-v3/include/c_global/cstdlib
+++ b/libstdc++-v3/include/c_global/cstdlib
@@ -1,6 +1,7 @@
 // -*- C++ -*- forwarding header.
 
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+// 2006, 2007
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -223,7 +224,22 @@ _GLIBCXX_END_NAMESPACE
 #endif // _GLIBCXX_USE_C99
 
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cstdlib>
+#  if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#    error C++0x header cannot be included from TR1 header
+#  endif
+#  if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#    include <tr1_impl/cstdlib>
+#  else
+#    define _GLIBCXX_INCLUDE_AS_CXX0X
+#    define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    define _GLIBCXX_END_NAMESPACE_TR1
+#    define _GLIBCXX_TR1
+#    include <tr1_impl/cstdlib>
+#    undef _GLIBCXX_TR1
+#    undef _GLIBCXX_END_NAMESPACE_TR1
+#    undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    undef _GLIBCXX_INCLUDE_AS_CXX0X
+#  endif
 #endif
 
 #endif // !_GLIBCXX_HOSTED
diff --git a/libstdc++-v3/include/c_global/ctgmath b/libstdc++-v3/include/c_global/ctgmath
index 623ed9b..2f3d7d0 100644
--- a/libstdc++-v3/include/c_global/ctgmath
+++ b/libstdc++-v3/include/c_global/ctgmath
@@ -36,10 +36,10 @@
 #ifndef _GLIBCXX_CTGMATH
 #define _GLIBCXX_CTGMATH 1
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/ctgmath>
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
+#  include <c++0x_warning.h>
 #else
-# include <c++0x_warning.h>
+#  include <cmath>
 #endif
 
 #endif 
diff --git a/libstdc++-v3/include/c_global/ctime b/libstdc++-v3/include/c_global/ctime
index 8b563ba..915c2fc 100644
--- a/libstdc++-v3/include/c_global/ctime
+++ b/libstdc++-v3/include/c_global/ctime
@@ -1,6 +1,7 @@
 // -*- C++ -*- forwarding header.
 
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+// 2006, 2007
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -79,8 +80,4 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
 
 _GLIBCXX_END_NAMESPACE
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/ctime>
-#endif
-
 #endif
diff --git a/libstdc++-v3/include/c_global/cwchar b/libstdc++-v3/include/c_global/cwchar
index c49ebbd..92bca61 100644
--- a/libstdc++-v3/include/c_global/cwchar
+++ b/libstdc++-v3/include/c_global/cwchar
@@ -278,7 +278,22 @@ _GLIBCXX_END_NAMESPACE
 #endif //_GLIBCXX_USE_WCHAR_T
 
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cwchar>
+#  if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#    error C++0x header cannot be included from TR1 header
+#  endif
+#  if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#    include <tr1_impl/cwchar>
+#  else
+#    define _GLIBCXX_INCLUDE_AS_CXX0X
+#    define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    define _GLIBCXX_END_NAMESPACE_TR1
+#    define _GLIBCXX_TR1
+#    include <tr1_impl/cwchar>
+#    undef _GLIBCXX_TR1
+#    undef _GLIBCXX_END_NAMESPACE_TR1
+#    undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    undef _GLIBCXX_INCLUDE_AS_CXX0X
+#  endif
 #endif
 
 #endif
diff --git a/libstdc++-v3/include/c_global/cwctype b/libstdc++-v3/include/c_global/cwctype
index 5c8d598..d2f2d77 100644
--- a/libstdc++-v3/include/c_global/cwctype
+++ b/libstdc++-v3/include/c_global/cwctype
@@ -1,6 +1,7 @@
 // -*- C++ -*- forwarding header.
 
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+// 2006, 2007
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -109,7 +110,22 @@ _GLIBCXX_END_NAMESPACE
 #endif //_GLIBCXX_USE_WCHAR_T
 
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cwctype>
+#  if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#    error C++0x header cannot be included from TR1 header
+#  endif
+#  if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#    include <tr1_impl/cwctype>
+#  else
+#    define _GLIBCXX_INCLUDE_AS_CXX0X
+#    define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    define _GLIBCXX_END_NAMESPACE_TR1
+#    define _GLIBCXX_TR1
+#    include <tr1_impl/cwctype>
+#    undef _GLIBCXX_TR1
+#    undef _GLIBCXX_END_NAMESPACE_TR1
+#    undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    undef _GLIBCXX_INCLUDE_AS_CXX0X
+#  endif
 #endif
 
 #endif
diff --git a/libstdc++-v3/include/ext/type_traits.h b/libstdc++-v3/include/ext/type_traits.h
index 8a896fa..746d866 100644
--- a/libstdc++-v3/include/ext/type_traits.h
+++ b/libstdc++-v3/include/ext/type_traits.h
@@ -159,6 +159,52 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
     __is_null_pointer(_Type)
     { return false; }
 
+
+  // For complex and cmath
+  template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
+    struct __promote
+    { typedef double __type; };
+
+  template<typename _Tp>
+    struct __promote<_Tp, false>
+    { typedef _Tp __type; };
+
+  template<typename _Tp, typename _Up>
+    struct __promote_2
+    {
+    private:
+      typedef typename __promote<_Tp>::__type __type1;
+      typedef typename __promote<_Up>::__type __type2;
+
+    public:
+      typedef __typeof__(__type1() + __type2()) __type;
+    };
+
+  template<typename _Tp, typename _Up, typename _Vp>
+    struct __promote_3
+    {
+    private:
+      typedef typename __promote<_Tp>::__type __type1;
+      typedef typename __promote<_Up>::__type __type2;
+      typedef typename __promote<_Vp>::__type __type3;
+
+    public:
+      typedef __typeof__(__type1() + __type2() + __type3()) __type;
+    };
+
+  template<typename _Tp, typename _Up, typename _Vp, typename _Wp>
+    struct __promote_4
+    {
+    private:
+      typedef typename __promote<_Tp>::__type __type1;
+      typedef typename __promote<_Up>::__type __type2;
+      typedef typename __promote<_Vp>::__type __type3;
+      typedef typename __promote<_Wp>::__type __type4;
+
+    public:
+      typedef __typeof__(__type1() + __type2() + __type3() + __type4()) __type;
+    };
+
 _GLIBCXX_END_NAMESPACE
 
 #endif 
diff --git a/libstdc++-v3/include/std/array b/libstdc++-v3/include/std/array
index 5ca26046..691f41c 100644
--- a/libstdc++-v3/include/std/array
+++ b/libstdc++-v3/include/std/array
@@ -31,16 +31,33 @@
  *  This is a Standard C++ Library header.
  */
 
-#ifndef _GLIBCXX_ARRAY
-#define _GLIBCXX_ARRAY 1
+#ifndef _GLIBCXX_CXX0X_ARRAY
+#define _GLIBCXX_CXX0X_ARRAY 1
 
 #pragma GCC system_header
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/array>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
 # include <c++0x_warning.h>
 #endif
 
-#endif 
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  error C++0x header cannot be included from TR1 header
+#endif
+
+#include <bits/stl_algobase.h>
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  include <tr1_impl/array>
+#else
+#  define _GLIBCXX_INCLUDE_AS_CXX0X
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  define _GLIBCXX_END_NAMESPACE_TR1
+#  define _GLIBCXX_TR1
+#  include <tr1_impl/array>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
 
+#endif // _GLIBCXX_CXX0X_ARRAY
diff --git a/libstdc++-v3/include/std/complex b/libstdc++-v3/include/std/complex
index 04a6c69..61d3580 100644
--- a/libstdc++-v3/include/std/complex
+++ b/libstdc++-v3/include/std/complex
@@ -47,6 +47,7 @@
 
 #include <bits/c++config.h>
 #include <bits/cpp_type_traits.h>
+#include <ext/type_traits.h>
 #include <cmath>
 #include <sstream>
 
@@ -1508,8 +1509,50 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
 
 _GLIBCXX_END_NAMESPACE
 
+_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+
+  // See ext/type_traits.h for the primary template.
+  template<typename _Tp, typename _Up>
+    struct __promote_2<std::complex<_Tp>, _Up>
+    {
+    public:
+      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
+    };
+
+  template<typename _Tp, typename _Up>
+    struct __promote_2<_Tp, std::complex<_Up> >
+    {
+    public:
+      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
+    };
+  
+  template<typename _Tp, typename _Up>
+    struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
+    {
+    public:
+      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
+    };
+
+_GLIBCXX_END_NAMESPACE
+
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/complex>
+#  if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#    error C++0x header cannot be included from TR1 header
+#  endif
+#  include <type_traits>
+#  if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#    include <tr1_impl/complex>
+#  else
+#    define _GLIBCXX_INCLUDE_AS_CXX0X
+#    define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    define _GLIBCXX_END_NAMESPACE_TR1
+#    define _GLIBCXX_TR1
+#    include <tr1_impl/complex>
+#    undef _GLIBCXX_TR1
+#    undef _GLIBCXX_END_NAMESPACE_TR1
+#    undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    undef _GLIBCXX_INCLUDE_AS_CXX0X
+#  endif
 #endif
 
 #endif	/* _GLIBCXX_COMPLEX */
diff --git a/libstdc++-v3/include/std/functional b/libstdc++-v3/include/std/functional
index 33bab64..27e8817 100644
--- a/libstdc++-v3/include/std/functional
+++ b/libstdc++-v3/include/std/functional
@@ -55,7 +55,29 @@
 #include <bits/stl_function.h>
 
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/functional>
+#  if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#    error C++0x header cannot be included from TR1 header
+#  endif
+#  include <cmath>
+#  include <string>
+#  include <typeinfo>
+#  include <ext/type_traits.h>
+#  include <tuple>
+#  include <type_traits>
+#  include <bits/functional_hash.h>
+#  if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#    include <tr1_impl/functional>
+#  else
+#    define _GLIBCXX_INCLUDE_AS_CXX0X
+#    define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    define _GLIBCXX_END_NAMESPACE_TR1
+#    define _GLIBCXX_TR1
+#    include <tr1_impl/functional>
+#    undef _GLIBCXX_TR1
+#    undef _GLIBCXX_END_NAMESPACE_TR1
+#    undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    undef _GLIBCXX_INCLUDE_AS_CXX0X
+#  endif
 #endif
 
-#endif /* _GLIBCXX_FUNCTIONAL */
+#endif // _GLIBCXX_FUNCTIONAL
diff --git a/libstdc++-v3/include/std/memory b/libstdc++-v3/include/std/memory
index 28b8d85..c48a5c3 100644
--- a/libstdc++-v3/include/std/memory
+++ b/libstdc++-v3/include/std/memory
@@ -60,7 +60,33 @@
 #include <bits/stl_raw_storage_iter.h>
 
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/memory>
+#  if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#    error C++0x header cannot be included from TR1 header
+#  endif
+#  include <exception>        	  // std::exception
+#  include <new>              	  // std::bad_alloc
+#  include <typeinfo>         	  // std::type_info in get_deleter
+#  include <bits/stl_algobase.h>  // std::swap
+#  include <iosfwd>           	  // std::basic_ostream
+#  include <ext/atomicity.h>
+#  include <ext/concurrence.h>
+#  include <bits/functexcept.h>
+#  include <bits/stl_function.h>  // std::less
+#  include <debug/debug.h>
+#  include <type_traits>
+#  if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#    include <tr1_impl/boost_shared_ptr.h>
+#  else
+#    define _GLIBCXX_INCLUDE_AS_CXX0X
+#    define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    define _GLIBCXX_END_NAMESPACE_TR1
+#    define _GLIBCXX_TR1
+#    include <tr1_impl/boost_shared_ptr.h>
+#    undef _GLIBCXX_TR1
+#    undef _GLIBCXX_END_NAMESPACE_TR1
+#    undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    undef _GLIBCXX_INCLUDE_AS_CXX0X
+#  endif
 #endif
 
 #endif /* _GLIBCXX_MEMORY */
diff --git a/libstdc++-v3/include/std/random b/libstdc++-v3/include/std/random
index 6faf5f5..2fccb60 100644
--- a/libstdc++-v3/include/std/random
+++ b/libstdc++-v3/include/std/random
@@ -36,11 +36,38 @@
 
 #pragma GCC system_header
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/random>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
 # include <c++0x_warning.h>
 #endif
 
-#endif 
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  error C++0x header cannot be included from TR1 header
+#endif
+
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <string>
+#include <iosfwd>
+#include <limits>
+#include <ext/type_traits.h>
+#include <ext/numeric_traits.h>
+#include <bits/concept_check.h>
+#include <debug/debug.h>
+#include <type_traits>
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  include <tr1_impl/random>
+#else
+#  define _GLIBCXX_INCLUDE_AS_CXX0X
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  define _GLIBCXX_END_NAMESPACE_TR1
+#  define _GLIBCXX_TR1
+#  include <tr1_impl/random>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
 
+#endif // _GLIBCXX_RANDOM
diff --git a/libstdc++-v3/include/std/regex b/libstdc++-v3/include/std/regex
index 4b4e482..5c25718 100644
--- a/libstdc++-v3/include/std/regex
+++ b/libstdc++-v3/include/std/regex
@@ -31,16 +31,40 @@
  *  This is a Standard C++ Library header.
  */
 
-#ifndef _GLIBCXX_REGEX
-#define _GLIBCXX_REGEX 1
+#ifndef _GLIBCXX_CXX0X_REGEX
+#define _GLIBCXX_CXX0X_REGEX 1
 
 #pragma GCC system_header
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/regex>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
 # include <c++0x_warning.h>
 #endif
 
-#endif 
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  error C++0x header cannot be included from TR1 header
+#endif
+
+#include <algorithm>
+#include <bitset>
+#include <iterator>
+#include <locale>
+#include <stdexcept>
+#include <string>
+#include <vector>
+#include <utility>
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  include <tr1_impl/regex>
+#else
+#  define _GLIBCXX_INCLUDE_AS_CXX0X
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  define _GLIBCXX_END_NAMESPACE_TR1
+#  define _GLIBCXX_TR1
+#  include <tr1_impl/regex>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
 
+#endif // _GLIBCXX_CXX0X_REGEX
diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple
index 7ea9aff..94e7ef5 100644
--- a/libstdc++-v3/include/std/tuple
+++ b/libstdc++-v3/include/std/tuple
@@ -31,16 +31,33 @@
  *  This is a Standard C++ Library header.
  */
 
-#ifndef _GLIBCXX_TUPLE
-#define _GLIBCXX_TUPLE 1
+#ifndef _GLIBCXX_CXX0X_TUPLE
+#define _GLIBCXX_CXX0X_TUPLE 1
 
 #pragma GCC system_header
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/tuple>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
 # include <c++0x_warning.h>
 #endif
 
-#endif 
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  error C++0x header cannot be included from TR1 header
+#endif
+
+#include <utility>
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  include <tr1_impl/tuple>
+#else
+#  define _GLIBCXX_INCLUDE_AS_CXX0X
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  define _GLIBCXX_END_NAMESPACE_TR1
+#  define _GLIBCXX_TR1
+#  include <tr1_impl/tuple>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
 
+#endif // _GLIBCXX_CXX0X_TUPLE
diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits
index 6806ebc..8dbfb56 100644
--- a/libstdc++-v3/include/std/type_traits
+++ b/libstdc++-v3/include/std/type_traits
@@ -31,18 +31,159 @@
  *  This is a Standard C++ Library header.
  */
 
-#ifndef _GLIBCXX_TYPE_TRAITS
-#define _GLIBCXX_TYPE_TRAITS 1
+#ifndef _GLIBCXX_CXX0X_TYPE_TRAITS
+#define _GLIBCXX_CXX0X_TYPE_TRAITS 1
 
 #pragma GCC system_header
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/type_traits>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
 # include <c++0x_warning.h>
 #endif
 
-_GLIBCXX_BEGIN_NAMESPACE(std)
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  error C++0x header cannot be included from TR1 header
+#endif
+
+#include <cstddef>
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  include <tr1_impl/type_traits>
+#else
+#  define _GLIBCXX_INCLUDE_AS_CXX0X
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  define _GLIBCXX_END_NAMESPACE_TR1
+#  define _GLIBCXX_TR1
+#  include <tr1_impl/type_traits>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
+
+namespace std
+{
+  template<typename _Tp,
+	   bool = is_integral<_Tp>::value,
+	   bool = is_floating_point<_Tp>::value>
+    struct __is_signed_helper
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_signed_helper<_Tp, false, true>
+    : public true_type { };
+
+  template<typename _Tp>
+    struct __is_signed_helper<_Tp, true, false>
+    : public integral_constant<bool, _Tp(-1) < _Tp(0)>
+    { };
+
+  template<typename _Tp>
+    struct is_signed
+    : public integral_constant<bool, __is_signed_helper<_Tp>::value>
+    { };
+
+  template<typename _Tp>
+    struct is_unsigned
+    : public integral_constant<bool, (is_arithmetic<_Tp>::value
+				      && !is_signed<_Tp>::value)>
+    { };
+
+  template<typename _Tp>
+    struct is_pod
+    : public integral_constant<bool, __is_pod(_Tp)>
+    { };
+
+  template<typename _Tp>
+    struct has_trivial_default_constructor
+    : public integral_constant<bool, __has_trivial_constructor(_Tp)>
+    { };
+
+  template<typename _Tp>
+    struct has_trivial_copy_constructor
+    : public integral_constant<bool, __has_trivial_copy(_Tp)>
+    { };
+
+  template<typename _Tp>
+    struct has_trivial_assign
+    : public integral_constant<bool, __has_trivial_assign(_Tp)>
+    { };
+
+  template<typename _Tp>
+    struct has_trivial_destructor
+    : public integral_constant<bool, __has_trivial_destructor(_Tp)>
+    { };
+
+  template<typename _Tp>
+    struct has_nothrow_default_constructor
+    : public integral_constant<bool, __has_nothrow_constructor(_Tp)>
+    { };
+
+  template<typename _Tp>
+    struct has_nothrow_copy_constructor
+    : public integral_constant<bool, __has_nothrow_copy(_Tp)>
+    { };
+
+  template<typename _Tp>
+    struct has_nothrow_assign
+    : public integral_constant<bool, __has_nothrow_assign(_Tp)>
+    { };
+
+  template<typename _Base, typename _Derived>
+    struct is_base_of
+    : public integral_constant<bool, __is_base_of(_Base, _Derived)>
+    { };
+
+  // XXX FIXME
+  // The C++0x specifications are different, see N2255.
+  template<typename _From, typename _To>
+    struct __is_convertible_simple
+    : public __sfinae_types
+    {
+    private:
+      static __one __test(_To);
+      static __two __test(...);
+      static _From __makeFrom();
+    
+    public:
+      static const bool __value = sizeof(__test(__makeFrom())) == 1;
+    };
+
+  template<typename _Tp>
+    struct __is_int_or_cref
+    {
+      typedef typename remove_reference<_Tp>::type __rr_Tp;
+      static const bool __value = (is_integral<_Tp>::value
+				   || (is_integral<__rr_Tp>::value
+				       && is_const<__rr_Tp>::value
+				       && !is_volatile<__rr_Tp>::value));
+    };
+
+  template<typename _From, typename _To,
+	   bool = (is_void<_From>::value || is_void<_To>::value
+		   || is_function<_To>::value || is_array<_To>::value
+		   // This special case is here only to avoid warnings.		   
+		   || (is_floating_point<typename
+		       remove_reference<_From>::type>::value
+		       && __is_int_or_cref<_To>::__value))>
+    struct __is_convertible_helper
+    {
+      // "An imaginary lvalue of type From...".
+      static const bool __value = (__is_convertible_simple<typename
+				   add_reference<_From>::type, _To>::__value);
+    };
+
+  template<typename _From, typename _To>
+    struct __is_convertible_helper<_From, _To, true>
+    { static const bool __value = (is_void<_To>::value
+				   || (__is_int_or_cref<_To>::__value
+				       && !is_void<_From>::value)); };
+
+  template<typename _From, typename _To>
+    struct is_convertible
+    : public integral_constant<bool,
+			       __is_convertible_helper<_From, _To>::__value>
+    { };
+
 
   // Define a nested type if some predicate holds.
   template<bool, typename _Tp = void>
@@ -131,7 +272,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
 
   // Utility for finding the unsigned versions of signed integral types.
   template<typename _Tp>
-    struct __make_unsigned;
+    struct __make_unsigned
+    { typedef _Tp __type; };
 
   template<>
     struct __make_unsigned<char>
@@ -165,16 +307,11 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
   // Select between integral and enum: not possible to be both.
   template<typename _Tp, 
 	   bool _IsInt = is_integral<_Tp>::value,
-	   bool _IsUnsigned = is_unsigned<_Tp>::value,
 	   bool _IsEnum = is_enum<_Tp>::value>
     struct __make_unsigned_selector;
   
   template<typename _Tp>
-    struct __make_unsigned_selector<_Tp, true, true, false>
-    { typedef _Tp __type; };
-
-  template<typename _Tp>
-    struct __make_unsigned_selector<_Tp, true, false, false>
+    struct __make_unsigned_selector<_Tp, true, false>
     {
     private:
       typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt;
@@ -186,7 +323,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
     };
 
   template<typename _Tp>
-    struct __make_unsigned_selector<_Tp, false, false, true>
+    struct __make_unsigned_selector<_Tp, false, true>
     {
     private:
       // GNU enums start with sizeof short.
@@ -214,7 +351,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
 
   // Utility for finding the signed versions of unsigned integral types.
   template<typename _Tp>
-    struct __make_signed;
+    struct __make_signed
+    { typedef _Tp __type; };
 
   template<>
     struct __make_signed<char>
@@ -248,16 +386,11 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
   // Select between integral and enum: not possible to be both.
   template<typename _Tp, 
 	   bool _IsInt = is_integral<_Tp>::value,
-	   bool _IsSigned = is_signed<_Tp>::value,
 	   bool _IsEnum = is_enum<_Tp>::value>
     struct __make_signed_selector;
   
   template<typename _Tp>
-    struct __make_signed_selector<_Tp, true, true, false>
-    { typedef _Tp __type; };
-
-  template<typename _Tp>
-    struct __make_signed_selector<_Tp, true, false, false>
+    struct __make_signed_selector<_Tp, true, false>
     {
     private:
       typedef __make_signed<typename remove_cv<_Tp>::type> __signedt;
@@ -269,7 +402,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
     };
 
   template<typename _Tp>
-    struct __make_signed_selector<_Tp, false, false, true>
+    struct __make_signed_selector<_Tp, false, true>
     {
     private:
       // GNU enums start with sizeof short.
@@ -293,25 +426,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
   // Integral, but don't define.
   template<>
     struct make_signed<bool>;
+}
 
-
-  template<typename _Tp>
-    struct has_nothrow_default_constructor
-    : public integral_constant<bool, is_pod<_Tp>::value> { };
-
-  template<typename _Tp>
-    struct has_nothrow_copy_constructor
-    : public integral_constant<bool, is_pod<_Tp>::value> { };
-
-  template<typename _Tp>
-    struct has_trivial_default_constructor
-    : public integral_constant<bool, is_pod<_Tp>::value> { };
-
-  template<typename _Tp>
-    struct has_trivial_copy_constructor
-    : public integral_constant<bool, is_pod<_Tp>::value> { };
-
-_GLIBCXX_END_NAMESPACE
-
-#endif 
+#endif  // _GLIBCXX_CXX0X_TYPE_TRAITS 
 
diff --git a/libstdc++-v3/include/std/unordered_map b/libstdc++-v3/include/std/unordered_map
index 9eee766..016d3ea 100644
--- a/libstdc++-v3/include/std/unordered_map
+++ b/libstdc++-v3/include/std/unordered_map
@@ -36,11 +36,36 @@
 
 #pragma GCC system_header
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/unordered_map>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
 # include <c++0x_warning.h>
 #endif
 
-#endif 
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  error C++0x header cannot be included from TR1 header
+#endif
+
+#include <cmath>
+#include <string>
+#include <utility>
+#include <algorithm> // lower_bound
+#include <bits/allocator.h>
+#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
+#include <type_traits>
+#include <bits/functional_hash.h>
+#include <bits/hashtable.h>
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  include <tr1_impl/unordered_map>
+#else
+#  define _GLIBCXX_INCLUDE_AS_CXX0X
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  define _GLIBCXX_END_NAMESPACE_TR1
+#  define _GLIBCXX_TR1
+#  include <tr1_impl/unordered_map>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
 
+#endif // _GLIBCXX_UNORDERED_MAP
diff --git a/libstdc++-v3/include/std/unordered_set b/libstdc++-v3/include/std/unordered_set
index d83cfa3..dba7816 100644
--- a/libstdc++-v3/include/std/unordered_set
+++ b/libstdc++-v3/include/std/unordered_set
@@ -36,11 +36,36 @@
 
 #pragma GCC system_header
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/unordered_set>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
 # include <c++0x_warning.h>
 #endif
 
-#endif 
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  error C++0x header cannot be included from TR1 header
+#endif
+
+#include <cmath>
+#include <string>
+#include <utility>
+#include <algorithm> // lower_bound
+#include <bits/allocator.h>
+#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
+#include <type_traits>
+#include <bits/functional_hash.h>
+#include <bits/hashtable.h>
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  include <tr1_impl/unordered_set>
+#else
+#  define _GLIBCXX_INCLUDE_AS_CXX0X
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  define _GLIBCXX_END_NAMESPACE_TR1
+#  define _GLIBCXX_TR1
+#  include <tr1_impl/unordered_set>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
 
+#endif // _GLIBCXX_UNORDERED_SET
diff --git a/libstdc++-v3/include/std/utility b/libstdc++-v3/include/std/utility
index c17b355..21440e5 100644
--- a/libstdc++-v3/include/std/utility
+++ b/libstdc++-v3/include/std/utility
@@ -67,7 +67,22 @@
 #include <bits/stl_pair.h>
 
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/utility>
+#  if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#    error C++0x header cannot be included from TR1 header
+#  endif
+#  if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#    include <tr1_impl/utility>
+#  else
+#    define _GLIBCXX_INCLUDE_AS_CXX0X
+#    define _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    define _GLIBCXX_END_NAMESPACE_TR1
+#    define _GLIBCXX_TR1
+#    include <tr1_impl/utility>
+#    undef _GLIBCXX_TR1
+#    undef _GLIBCXX_END_NAMESPACE_TR1
+#    undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#    undef _GLIBCXX_INCLUDE_AS_CXX0X
+#  endif
 #endif
 
 #endif /* _GLIBCXX_UTILITY */
diff --git a/libstdc++-v3/include/tr1/array b/libstdc++-v3/include/tr1/array
index 34508df..cca9520 100644
--- a/libstdc++-v3/include/tr1/array
+++ b/libstdc++-v3/include/tr1/array
@@ -31,216 +31,29 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_ARRAY
-#define _TR1_ARRAY 1
+#ifndef _GLIBCXX_TR1_ARRAY
+#define _GLIBCXX_TR1_ARRAY 1
 
-#include <bits/stl_algobase.h>
-
-//namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-  /// @brief  struct array [6.2.2].
-  /// NB: Requires complete type _Tp.
-  template<typename _Tp, std::size_t _Nm>
-    struct array
-    {
-      typedef _Tp 	    			      value_type;
-      typedef value_type&                   	      reference;
-      typedef const value_type&             	      const_reference;
-      typedef value_type*          		      iterator;
-      typedef const value_type*			      const_iterator;
-      typedef std::size_t                    	      size_type;
-      typedef std::ptrdiff_t                   	      difference_type;
-      typedef std::reverse_iterator<iterator>	      reverse_iterator;
-      typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;
-
-      // Support for zero-sized arrays mandatory.
-      value_type _M_instance[_Nm ? _Nm : 1] __attribute__((__aligned__));
-
-      // No explicit construct/copy/destroy for aggregate type.
-
-      void 
-      assign(const value_type& __u)
-      { std::fill_n(begin(), size(), __u); }
-
-      void 
-      swap(array& __other)
-      { std::swap_ranges(begin(), end(), __other.begin()); }
-
-      // Iterators.
-      iterator
-      begin()
-      { return iterator(&_M_instance[0]); }
-
-      const_iterator
-      begin() const 
-      { return const_iterator(&_M_instance[0]); }
-
-      iterator
-      end() 
-      { return iterator(&_M_instance[_Nm]); }
-
-      const_iterator
-      end() const
-      { return const_iterator(&_M_instance[_Nm]); }
-
-      reverse_iterator 
-      rbegin()
-      { return reverse_iterator(end()); }
-
-      const_reverse_iterator 
-      rbegin() const
-      { return const_reverse_iterator(end()); }
-
-      reverse_iterator 
-      rend()
-      { return reverse_iterator(begin()); }
-
-      const_reverse_iterator 
-      rend() const
-      { return const_reverse_iterator(begin()); }
-
-      // Capacity.
-      size_type 
-      size() const { return _Nm; }
-
-      size_type 
-      max_size() const { return _Nm; }
-
-      bool 
-      empty() const { return size() == 0; }
-
-      // Element access.
-      reference
-      operator[](size_type __n)
-      { return _M_instance[__n]; }
-
-      const_reference
-      operator[](size_type __n) const
-      { return _M_instance[__n]; }
-
-      reference
-      at(size_type __n)
-      { 
-	_M_check<_Nm>(__n);
-	return _M_instance[__n];
-      }
-
-      const_reference
-      at(size_type __n) const
-      {
-	_M_check<_Nm>(__n);
-	return _M_instance[__n];
-      }
-
-      reference 
-      front()
-      { return *begin(); }
+#pragma GCC system_header
 
-      const_reference 
-      front() const
-      { return *begin(); }
-
-      reference 
-      back()
-      { return _Nm ? *(end() - 1) : *end(); }
-
-      const_reference 
-      back() const
-      { return _Nm ? *(end() - 1) : *end(); }
-
-      _Tp* 
-      data()
-      { return &_M_instance[0]; }
-
-      const _Tp* 
-      data() const
-      { return &_M_instance[0]; }
-
-    private:
-      template<std::size_t _Mm>
-        typename __gnu_cxx::__enable_if<_Mm, void>::__type
-        _M_check(size_type __n) const
-        {
-	  if (__builtin_expect(__n >= _Mm, false))
-	    std::__throw_out_of_range(__N("array::_M_check"));
-	}
-
-      // Avoid "unsigned comparison with zero" warnings.
-      template<std::size_t _Mm>
-        typename __gnu_cxx::__enable_if<!_Mm, void>::__type
-        _M_check(size_type) const
-        { std::__throw_out_of_range(__N("array::_M_check")); }
-    };
-
-  // Array comparisons.
-  template<typename _Tp, std::size_t _Nm>
-    inline bool 
-    operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-    { return std::equal(__one.begin(), __one.end(), __two.begin()); }
-
-  template<typename _Tp, std::size_t _Nm>
-    inline bool
-    operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-    { return !(__one == __two); }
-
-  template<typename _Tp, std::size_t _Nm>
-    inline bool
-    operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
-    { 
-      return std::lexicographical_compare(__a.begin(), __a.end(),
-					  __b.begin(), __b.end()); 
-    }
-
-  template<typename _Tp, std::size_t _Nm>
-    inline bool
-    operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-    { return __two < __one; }
-
-  template<typename _Tp, std::size_t _Nm>
-    inline bool
-    operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-    { return !(__one > __two); }
-
-  template<typename _Tp, std::size_t _Nm>
-    inline bool
-    operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-    { return !(__one < __two); }
-
-  // Specialized algorithms [6.2.2.2].
-  template<typename _Tp, std::size_t _Nm>
-    inline void
-    swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
-    { std::swap_ranges(__one.begin(), __one.end(), __two.begin()); }
-
-  // Tuple interface to class template array [6.2.2.5].
-  template<typename _Tp> class tuple_size;
-  template<int _Int, typename _Tp> class tuple_element;
-
-  template<typename _Tp, std::size_t _Nm>
-    struct tuple_size<array<_Tp, _Nm> >
-    { static const int value = _Nm; };
-
-  template<typename _Tp, std::size_t _Nm>
-    const int tuple_size<array<_Tp, _Nm> >::value;
-
-  template<int _Int, typename _Tp, std::size_t _Nm>
-    struct tuple_element<_Int, array<_Tp, _Nm> >
-    { typedef _Tp type; };
-
-  template<int _Int, typename _Tp, std::size_t _Nm>
-    inline _Tp&
-    get(array<_Tp, _Nm>& __arr)
-    { return __arr[_Int]; }
-
-  template<int _Int, typename _Tp, std::size_t _Nm>
-    inline const _Tp&
-    get(const array<_Tp, _Nm>& __arr)
-    { return __arr[_Int]; }
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
 
-_GLIBCXX_END_NAMESPACE
-}
+#include <bits/stl_algobase.h>
 
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/array>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/array>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
 #endif
+
+#endif // _GLIBCXX_TR1_ARRAY
diff --git a/libstdc++-v3/include/tr1/bessel_function.tcc b/libstdc++-v3/include/tr1/bessel_function.tcc
index 68ca9a3..eebafac4 100644
--- a/libstdc++-v3/include/tr1/bessel_function.tcc
+++ b/libstdc++-v3/include/tr1/bessel_function.tcc
@@ -49,14 +49,15 @@
 //       W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
 //       2nd ed, pp. 240-245
 
-#ifndef _TR1_BESSEL_FUNCTION_TCC
-#define _TR1_BESSEL_FUNCTION_TCC 1
+#ifndef _GLIBCXX_TR1_BESSEL_FUNCTION_TCC
+#define _GLIBCXX_TR1_BESSEL_FUNCTION_TCC 1
 
 #include "special_function_util.h"
 
 namespace std
 {
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
 
   // [5.2] Special functions
 
@@ -102,8 +103,8 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
                    _Tp & __gam1, _Tp & __gam2, _Tp & __gampl, _Tp & __gammi)
     {
 #if _GLIBCXX_USE_C99_MATH_TR1
-      __gampl = _Tp(1) / std::_GLIBCXX_TR1::tgamma(_Tp(1) + __mu);
-      __gammi = _Tp(1) / std::_GLIBCXX_TR1::tgamma(_Tp(1) - __mu);
+      __gampl = _Tp(1) / std::tr1::tgamma(_Tp(1) + __mu);
+      __gammi = _Tp(1) / std::tr1::tgamma(_Tp(1) - __mu);
 #else
       __gampl = _Tp(1) / __gamma(_Tp(1) + __mu);
       __gammi = _Tp(1) / __gamma(_Tp(1) - __mu);
@@ -318,7 +319,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
           const _Tp __gam = (__p - __f) / __q;
           __Jmu = std::sqrt(__w / ((__p - __f) * __gam + __q));
 #if _GLIBCXX_USE_C99_MATH_TR1
-          __Jmu = std::_GLIBCXX_TR1::copysign(__Jmu, __Jnul);
+          __Jmu = std::tr1::copysign(__Jmu, __Jnul);
 #else
           if (__Jmu * __Jnul < _Tp(0))
             __Jmu = -__Jmu;
@@ -425,7 +426,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
       const _Tp __x2 = __x / _Tp(2);
       _Tp __fact = __nu * std::log(__x2);
 #if _GLIBCXX_USE_C99_MATH_TR1
-      __fact -= std::_GLIBCXX_TR1::lgamma(__nu + _Tp(1));
+      __fact -= std::tr1::lgamma(__nu + _Tp(1));
 #else
       __fact -= __log_gamma(__nu + _Tp(1));
 #endif
@@ -635,7 +636,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 
   /* @} */ // group tr1_math_spec_func
 
-_GLIBCXX_END_NAMESPACE
+}
 }
 
-#endif // _TR1_BESSEL_FUNCTION_TCC
+#endif // _GLIBCXX_TR1_BESSEL_FUNCTION_TCC
diff --git a/libstdc++-v3/include/tr1/beta_function.tcc b/libstdc++-v3/include/tr1/beta_function.tcc
index a460117..537947e 100644
--- a/libstdc++-v3/include/tr1/beta_function.tcc
+++ b/libstdc++-v3/include/tr1/beta_function.tcc
@@ -49,12 +49,13 @@
 //   (4) Gamma, Exploring Euler's Constant, Julian Havil,
 //       Princeton, 2003.
 
-#ifndef _TR1_BETA_FUNCTION_TCC
-#define _TR1_BETA_FUNCTION_TCC 1
+#ifndef _GLIBCXX_TR1_BETA_FUNCTION_TCC
+#define _GLIBCXX_TR1_BETA_FUNCTION_TCC 1
 
 namespace std
 {
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
 
   // [5.2] Special functions
 
@@ -90,15 +91,15 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 #if _GLIBCXX_USE_C99_MATH_TR1
       if (__x > __y)
         {
-          __bet = std::_GLIBCXX_TR1::tgamma(__x)
-                / std::_GLIBCXX_TR1::tgamma(__x + __y);
-          __bet *= std::_GLIBCXX_TR1::tgamma(__y);
+          __bet = std::tr1::tgamma(__x)
+                / std::tr1::tgamma(__x + __y);
+          __bet *= std::tr1::tgamma(__y);
         }
       else
         {
-          __bet = std::_GLIBCXX_TR1::tgamma(__y)
-                / std::_GLIBCXX_TR1::tgamma(__x + __y);
-          __bet *= std::_GLIBCXX_TR1::tgamma(__x);
+          __bet = std::tr1::tgamma(__y)
+                / std::tr1::tgamma(__x + __y);
+          __bet *= std::tr1::tgamma(__x);
         }
 #else
       if (__x > __y)
@@ -134,9 +135,9 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
     __beta_lgamma(_Tp __x, _Tp __y)
     {
 #if _GLIBCXX_USE_C99_MATH_TR1
-      _Tp __bet = std::_GLIBCXX_TR1::lgamma(__x)
-                + std::_GLIBCXX_TR1::lgamma(__y)
-                - std::_GLIBCXX_TR1::lgamma(__x + __y);
+      _Tp __bet = std::tr1::lgamma(__x)
+                + std::tr1::lgamma(__y)
+                - std::tr1::lgamma(__x + __y);
 #else
       _Tp __bet = __log_gamma(__x)
                 + __log_gamma(__y)
@@ -205,7 +206,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 
   /* @} */ // group tr1_math_spec_func
 
-_GLIBCXX_END_NAMESPACE
+}
 }
 
-#endif // _TR1_BETA_FUNCTION_TCC
+#endif // __GLIBCXX_TR1_BETA_FUNCTION_TCC
diff --git a/libstdc++-v3/include/tr1/ccomplex b/libstdc++-v3/include/tr1/ccomplex
index a919645..98f2cdc 100644
--- a/libstdc++-v3/include/tr1/ccomplex
+++ b/libstdc++-v3/include/tr1/ccomplex
@@ -31,9 +31,9 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_CCOMPLEX
-#define _TR1_CCOMPLEX 1
+#ifndef _GLIBCXX_TR1_CCOMPLEX
+#define _GLIBCXX_TR1_CCOMPLEX 1
 
 #include <tr1/complex>
 
-#endif
+#endif // _GLIBCXX_TR1_CCOMPLEX
diff --git a/libstdc++-v3/include/tr1/cctype b/libstdc++-v3/include/tr1/cctype
index 7d428f9..72607d7 100644
--- a/libstdc++-v3/include/tr1/cctype
+++ b/libstdc++-v3/include/tr1/cctype
@@ -1,6 +1,6 @@
 // TR1 cctype -*- C++ -*-
 
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -31,26 +31,24 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_CCTYPE
-#define _TR1_CCTYPE 1
+#ifndef _GLIBCXX_TR1_CCTYPE
+#define _GLIBCXX_TR1_CCTYPE 1
 
 #include <bits/c++config.h>
 #include <cctype>
 
-#if _GLIBCXX_USE_C99_CTYPE_TR1
-
-#undef isblank
-
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-  using ::isblank;
-
-_GLIBCXX_END_NAMESPACE
-}
-
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/cctype>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/cctype>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
 #endif
 
-#endif
+#endif // _GLIBCXX_TR1_CCTYPE
diff --git a/libstdc++-v3/include/tr1/cfenv b/libstdc++-v3/include/tr1/cfenv
index dc9fff8..8544712 100644
--- a/libstdc++-v3/include/tr1/cfenv
+++ b/libstdc++-v3/include/tr1/cfenv
@@ -1,6 +1,6 @@
-// TR1 cctype -*- C++ -*-
+// TR1 cfenv -*- C++ -*-
 
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -31,54 +31,23 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_CFENV
-#define _TR1_CFENV 1
+#ifndef _GLIBCXX_TR1_CFENV
+#define _GLIBCXX_TR1_CFENV 1
 
 #include <bits/c++config.h>
 
-#if _GLIBCXX_USE_C99_FENV_TR1
-
-#include_next <fenv.h>
-
-#undef feclearexcept
-#undef fegetexceptflag
-#undef feraiseexcept
-#undef fesetexceptflag
-#undef fetestexcept
-#undef fegetround
-#undef fesetround
-#undef fegetenv
-#undef feholdexcept
-#undef fesetenv
-#undef feupdateenv
-
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-  // types
-  using ::fenv_t;
-  using ::fexcept_t;
-
-  // functions
-  using ::feclearexcept;
-  using ::fegetexceptflag;
-  using ::feraiseexcept;
-  using ::fesetexceptflag;
-  using ::fetestexcept;
-
-  using ::fegetround;
-  using ::fesetround;
-
-  using ::fegetenv;
-  using ::feholdexcept;
-  using ::fesetenv;
-  using ::feupdateenv;
-  
-_GLIBCXX_END_NAMESPACE
-}
-
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/cfenv>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/cfenv>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
 #endif
 
-#endif
+#endif // _GLIBCXX_TR1_CFENV
diff --git a/libstdc++-v3/include/tr1/cfloat b/libstdc++-v3/include/tr1/cfloat
index 1514ff7..86f3af8 100644
--- a/libstdc++-v3/include/tr1/cfloat
+++ b/libstdc++-v3/include/tr1/cfloat
@@ -1,6 +1,6 @@
 // TR1 cfloat -*- C++ -*-
 
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -31,8 +31,8 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_CFLOAT
-#define _TR1_CFLOAT 1
+#ifndef _GLIBCXX_TR1_CFLOAT
+#define _GLIBCXX_TR1_CFLOAT 1
 
 #include <cfloat>
 
@@ -44,4 +44,4 @@
 #define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
 #endif
 
-#endif
+#endif //_GLIBCXX_TR1_CFLOAT 
diff --git a/libstdc++-v3/include/tr1/cinttypes b/libstdc++-v3/include/tr1/cinttypes
index e2d2fcd..19e2df3 100644
--- a/libstdc++-v3/include/tr1/cinttypes
+++ b/libstdc++-v3/include/tr1/cinttypes
@@ -31,51 +31,23 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_CINTTYPES
-#define _TR1_CINTTYPES 1
+#ifndef _GLIBCXX_TR1_CINTTYPES
+#define _GLIBCXX_TR1_CINTTYPES 1
 
-#include <bits/c++config.h>
 #include <tr1/cstdint>
 
-#if _GLIBCXX_USE_C99_INTTYPES_TR1
-
-// For 8.11.1/1 (see C99, Note 184) 
-#define __STDC_FORMAT_MACROS
-#include_next <inttypes.h>
-
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-  // types
-  using ::imaxdiv_t;
-
-  // functions
-  using ::imaxabs;
-
-  // May collide with _Longlong abs(_Longlong), and is not described
-  // anywhere outside the synopsis.  Likely, a defect.
-  //
-  // intmax_t abs(intmax_t)
-
-  using ::imaxdiv;
-
-  // Likewise, with lldiv_t div(_Longlong, _Longlong).
-  //
-  // imaxdiv_t div(intmax_t, intmax_t)
-
-  using ::strtoimax;
-  using ::strtoumax;
-
-#ifdef _GLIBCXX_USE_WCHAR_T
-  using ::wcstoimax;
-  using ::wcstoumax;
-#endif
-
-_GLIBCXX_END_NAMESPACE
-}
-
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/cinttypes>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/cinttypes>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
 #endif
 
-#endif
+#endif // _GLIBCXX_TR1_CINTTYPES
diff --git a/libstdc++-v3/include/tr1/climits b/libstdc++-v3/include/tr1/climits
index dc04729..9c7b0c5 100644
--- a/libstdc++-v3/include/tr1/climits
+++ b/libstdc++-v3/include/tr1/climits
@@ -1,6 +1,6 @@
 // TR1 climits -*- C++ -*-
 
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -31,8 +31,8 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_CLIMITS
-#define _TR1_CLIMITS 1
+#ifndef _GLIBCXX_TR1_CLIMITS
+#define _GLIBCXX_TR1_CLIMITS 1
 
 #include <climits>
 
@@ -48,4 +48,4 @@
 #define ULLONG_MAX __LONG_LONG_MAX__ * 2ULL + 1
 #endif
 
-#endif
+#endif // _GLIBCXX_TR1_CLIMITS
diff --git a/libstdc++-v3/include/tr1/cmath b/libstdc++-v3/include/tr1/cmath
index f1cb1e6..70d65f5 100644
--- a/libstdc++-v3/include/tr1/cmath
+++ b/libstdc++-v3/include/tr1/cmath
@@ -31,925 +31,42 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_CMATH
-#define _TR1_CMATH 1
+#ifndef _GLIBCXX_TR1_CMATH
+#define _GLIBCXX_TR1_CMATH 1
 
-#include <bits/c++config.h>
-#include <bits/stl_algobase.h>
-#include <limits>
-#include <cmath>
-#include <tr1/common.h>
-
-#if _GLIBCXX_USE_C99_MATH_TR1
-
-#undef acosh
-#undef acoshf
-#undef acoshl
-#undef asinh
-#undef asinhf
-#undef asinhl
-#undef atanh
-#undef atanhf
-#undef atanhl
-#undef cbrt
-#undef cbrtf
-#undef cbrtl
-#undef copysign
-#undef copysignf
-#undef copysignl
-#undef erf
-#undef erff
-#undef erfl
-#undef erfc
-#undef erfcf
-#undef erfcl
-#undef exp2
-#undef exp2f
-#undef exp2l
-#undef expm1
-#undef expm1f
-#undef expm1l
-#undef fdim
-#undef fdimf
-#undef fdiml
-#undef fma
-#undef fmaf
-#undef fmal
-#undef fmax
-#undef fmaxf
-#undef fmaxl
-#undef fmin
-#undef fminf
-#undef fminl
-#undef hypot
-#undef hypotf
-#undef hypotl
-#undef ilogb
-#undef ilogbf
-#undef ilogbl
-#undef lgamma
-#undef lgammaf
-#undef lgammal
-#undef llrint
-#undef llrintf
-#undef llrintl
-#undef llround
-#undef llroundf
-#undef llroundl
-#undef log1p
-#undef log1pf
-#undef log1pl
-#undef log2
-#undef log2f
-#undef log2l
-#undef logb
-#undef logbf
-#undef logbl
-#undef lrint
-#undef lrintf
-#undef lrintl
-#undef lround
-#undef lroundf
-#undef lroundl
-#undef nan
-#undef nanf
-#undef nanl
-#undef nearbyint
-#undef nearbyintf
-#undef nearbyintl
-#undef nextafter
-#undef nextafterf
-#undef nextafterl
-#undef nexttoward
-#undef nexttowardf
-#undef nexttowardl
-#undef remainder
-#undef remainderf
-#undef remainderl
-#undef remquo
-#undef remquo
-#undef remquo
-#undef rint
-#undef rintf
-#undef rintl
-#undef round
-#undef roundf
-#undef roundl
-#undef scalbln
-#undef scalblnf
-#undef scalblnl
-#undef scalbn
-#undef scalbnf
-#undef scalbnl
-#undef tgamma
-#undef tgammaf
-#undef tgammal
-#undef trunc
-#undef truncf
-#undef truncl
+#pragma GCC system_header
 
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
 #endif
 
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-#if _GLIBCXX_USE_C99_MATH_TR1
-
-  // types
-  using ::double_t;
-  using ::float_t;
-
-  // functions
-  using ::acosh;
-  using ::acoshf;
-  using ::acoshl;
-
-  using ::asinh;
-  using ::asinhf;
-  using ::asinhl;
-
-  using ::atanh;
-  using ::atanhf;
-  using ::atanhl;
-
-  using ::cbrt;
-  using ::cbrtf;
-  using ::cbrtl;
-
-  using ::copysign;
-  using ::copysignf;
-  using ::copysignl;
-
-  using ::erf;
-  using ::erff;
-  using ::erfl;
-
-  using ::erfc;
-  using ::erfcf;
-  using ::erfcl;
-
-  using ::exp2;
-  using ::exp2f;
-  using ::exp2l;
-
-  using ::expm1;
-  using ::expm1f;
-  using ::expm1l;
-
-  using ::fdim;
-  using ::fdimf;
-  using ::fdiml;
-
-  using ::fma;
-  using ::fmaf;
-  using ::fmal;
-
-  using ::fmax;
-  using ::fmaxf;
-  using ::fmaxl;
-
-  using ::fmin;
-  using ::fminf;
-  using ::fminl;
-
-  using ::hypot;
-  using ::hypotf;
-  using ::hypotl;
-
-  using ::ilogb;
-  using ::ilogbf;
-  using ::ilogbl;
-
-  using ::lgamma;
-  using ::lgammaf;
-  using ::lgammal;
-
-  using ::llrint;
-  using ::llrintf;
-  using ::llrintl;
-
-  using ::llround;
-  using ::llroundf;
-  using ::llroundl;
-
-  using ::log1p;
-  using ::log1pf;
-  using ::log1pl;
-
-  using ::log2;
-  using ::log2f;
-  using ::log2l;
-
-  using ::logb;
-  using ::logbf;
-  using ::logbl;
-
-  using ::lrint;
-  using ::lrintf;
-  using ::lrintl;
-
-  using ::lround;
-  using ::lroundf;
-  using ::lroundl;
-
-  using ::nan;
-  using ::nanf;
-  using ::nanl;
-
-  using ::nearbyint;
-  using ::nearbyintf;
-  using ::nearbyintl;
-
-  using ::nextafter;
-  using ::nextafterf;
-  using ::nextafterl;
-
-  using ::nexttoward;
-  using ::nexttowardf;
-  using ::nexttowardl;
-
-  using ::remainder;
-  using ::remainderf;
-  using ::remainderl;
-
-  using ::remquo;
-  using ::remquo;
-  using ::remquo;
-
-  using ::rint;
-  using ::rintf;
-  using ::rintl;
-
-  using ::round;
-  using ::roundf;
-  using ::roundl;
-
-  using ::scalbln;
-  using ::scalblnf;
-  using ::scalblnl;
-
-  using ::scalbn;
-  using ::scalbnf;
-  using ::scalbnl;
-
-  using ::tgamma;
-  using ::tgammaf;
-  using ::tgammal;
-
-  using ::trunc;
-  using ::truncf;
-  using ::truncl;
-
-#endif
-
-#if _GLIBCXX_USE_C99_MATH
-#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
-
-  /// @brief Function template definitions [8.16.3].
-  //
-  using std::signbit;
-  
-  using std::fpclassify;
-
-  using std::isfinite;
-  using std::isinf;
-  using std::isnan;
-  using std::isnormal;
-
-  using std::isgreater;
-  using std::isgreaterequal;
-  using std::isless;
-  using std::islessequal;
-  using std::islessgreater;
-  using std::isunordered;
-#endif
-#endif
-
-#if _GLIBCXX_USE_C99_MATH_TR1
-
-  /// @brief Additional overloads [8.16.4].
-  //
-  using std::acos;
-
-  inline float
-  acosh(float __x)
-  { return __builtin_acoshf(__x); }
-
-  inline long double
-  acosh(long double __x)
-  { return __builtin_acoshl(__x); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type 
-    acosh(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return acosh(__type(__x));
-    }
-
-  using std::asin;
-
-  inline float
-  asinh(float __x)
-  { return __builtin_asinhf(__x); }
-
-  inline long double
-  asinh(long double __x)
-  { return __builtin_asinhl(__x); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type 
-    asinh(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return asinh(__type(__x));
-    }
-
-  using std::atan;
-
-  // Workaround for c++/21682.
-  namespace __detail
-  {
-    template<typename _Tp, typename _Up>
-      inline typename
-      __gnu_cxx::__enable_if<std::__is_floating<_Tp>::__value
-                             || std::__is_floating<_Up>::__value,
-			     typename std::_GLIBCXX_TR1::
-			     __promote_2<_Tp, _Up>::__type>::__type
-      atan2(_Tp __y, _Up __x)
-      {
-	typedef typename std::_GLIBCXX_TR1::__promote_2<_Tp, _Up>::__type
-	  __type;
-	return std::atan2(__type(__y), __type(__x));
-      }
-  } // namespace __detail
-
-  using std::atan2;
-  using __detail::atan2;
- 
-  inline float
-  atanh(float __x)
-  { return __builtin_atanhf(__x); }
-
-  inline long double
-  atanh(long double __x)
-  { return __builtin_atanhl(__x); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type 
-    atanh(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return atanh(__type(__x));
-    }
-
-  inline float
-  cbrt(float __x)
-  { return __builtin_cbrtf(__x); }
-
-  inline long double
-  cbrt(long double __x)
-  { return __builtin_cbrtl(__x); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type 
-    cbrt(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return cbrt(__type(__x));
-    }
-
-  using std::ceil;
-
-  inline float
-  copysign(float __x, float __y)
-  { return __builtin_copysignf(__x, __y); }
-
-  inline long double
-  copysign(long double __x, long double __y)
-  { return __builtin_copysignl(__x, __y); }
-
-  template<typename _Tp, typename _Up>
-    inline typename __promote_2<_Tp, _Up>::__type
-    copysign(_Tp __x, _Up __y)
-    {
-      typedef typename __promote_2<_Tp, _Up>::__type __type;
-      return copysign(__type(__x), __type(__y));
-    }
-
-  using std::cos;
-  using std::cosh;  
-
-  inline float
-  erf(float __x)
-  { return __builtin_erff(__x); }
-
-  inline long double
-  erf(long double __x)
-  { return __builtin_erfl(__x); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type 
-    erf(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return erf(__type(__x));
-    }
-
-  inline float
-  erfc(float __x)
-  { return __builtin_erfcf(__x); }
-
-  inline long double
-  erfc(long double __x)
-  { return __builtin_erfcl(__x); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type 
-    erfc(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return erfc(__type(__x));
-    }
-
-  using std::exp;
-
-  inline float
-  exp2(float __x)
-  { return __builtin_exp2f(__x); }
-
-  inline long double
-  exp2(long double __x)
-  { return __builtin_exp2l(__x); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type 
-    exp2(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return exp2(__type(__x));
-    }
-
-  inline float
-  expm1(float __x)
-  { return __builtin_expm1f(__x); }
-
-  inline long double
-  expm1(long double __x)
-  { return __builtin_expm1l(__x); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type 
-    expm1(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return expm1(__type(__x));
-    }
-
-  using std::fabs;
-
-  inline float
-  fdim(float __x, float __y)
-  { return __builtin_fdimf(__x, __y); }
-
-  inline long double
-  fdim(long double __x, long double __y)
-  { return __builtin_fdiml(__x, __y); }
-
-  template<typename _Tp, typename _Up>
-    inline typename __promote_2<_Tp, _Up>::__type
-    fdim(_Tp __x, _Up __y)
-    {
-      typedef typename __promote_2<_Tp, _Up>::__type __type;
-      return fdim(__type(__x), __type(__y));
-    }
-
-  using std::floor;
-
-  inline float
-  fma(float __x, float __y, float __z)
-  { return __builtin_fmaf(__x, __y, __z); }
-
-  inline long double
-  fma(long double __x, long double __y, long double __z)
-  { return __builtin_fmal(__x, __y, __z); }
-
-  template<typename _Tp, typename _Up, typename _Vp>
-    inline typename __promote_3<_Tp, _Up, _Vp>::__type
-    fma(_Tp __x, _Up __y, _Vp __z)
-    {
-      typedef typename __promote_3<_Tp, _Up, _Vp>::__type __type;
-      return fma(__type(__x), __type(__y), __type(__z));
-    }
-
-  inline float
-  fmax(float __x, float __y)
-  { return __builtin_fmaxf(__x, __y); }
-
-  inline long double
-  fmax(long double __x, long double __y)
-  { return __builtin_fmaxl(__x, __y); }
-
-  template<typename _Tp, typename _Up>
-    inline typename __promote_2<_Tp, _Up>::__type
-    fmax(_Tp __x, _Up __y)
-    {
-      typedef typename __promote_2<_Tp, _Up>::__type __type;
-      return fmax(__type(__x), __type(__y));
-    }
-
-  inline float
-  fmin(float __x, float __y)
-  { return __builtin_fminf(__x, __y); }
-
-  inline long double
-  fmin(long double __x, long double __y)
-  { return __builtin_fminl(__x, __y); }
-
-  template<typename _Tp, typename _Up>
-    inline typename __promote_2<_Tp, _Up>::__type
-    fmin(_Tp __x, _Up __y)
-    {
-      typedef typename __promote_2<_Tp, _Up>::__type __type;
-      return fmin(__type(__x), __type(__y));
-    }
-
-  using std::fmod;
-  using std::frexp;
-
-  inline float
-  hypot(float __x, float __y)
-  { return __builtin_hypotf(__x, __y); }
-
-  inline long double
-  hypot(long double __x, long double __y)
-  { return __builtin_hypotl(__x, __y); }
-
-  template<typename _Tp, typename _Up>
-    inline typename __promote_2<_Tp, _Up>::__type
-    hypot(_Tp __x, _Up __y)
-    {
-      typedef typename __promote_2<_Tp, _Up>::__type __type;
-      return hypot(__type(__x), __type(__y));
-    }
-
-  inline int
-  ilogb(float __x)
-  { return __builtin_ilogbf(__x); }
-
-  inline int
-  ilogb(long double __x)
-  { return __builtin_ilogbl(__x); }
-
-  template<typename _Tp>
-    inline int
-    ilogb(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return ilogb(__type(__x));
-    }
-
-  using std::ldexp;
-
-  inline float
-  lgamma(float __x)
-  { return __builtin_lgammaf(__x); }
-
-  inline long double
-  lgamma(long double __x)
-  { return __builtin_lgammal(__x); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type 
-    lgamma(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return lgamma(__type(__x));
-    }
-
-  inline long long
-  llrint(float __x)
-  { return __builtin_llrintf(__x); }
-
-  inline long long
-  llrint(long double __x)
-  { return __builtin_llrintl(__x); }
-
-  template<typename _Tp>
-    inline long long
-    llrint(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return llrint(__type(__x));
-    }
-
-  inline long long
-  llround(float __x)
-  { return __builtin_llroundf(__x); }
-
-  inline long long
-  llround(long double __x)
-  { return __builtin_llroundl(__x); }
-
-  template<typename _Tp>
-    inline long long
-    llround(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return llround(__type(__x));
-    }
-
-  using std::log;
-  using std::log10;
-
-  inline float
-  log1p(float __x)
-  { return __builtin_log1pf(__x); }
-
-  inline long double
-  log1p(long double __x)
-  { return __builtin_log1pl(__x); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type 
-    log1p(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return log1p(__type(__x));
-    }
-
-  // DR 568.
-  inline float
-  log2(float __x)
-  { return __builtin_log2f(__x); }
-
-  inline long double
-  log2(long double __x)
-  { return __builtin_log2l(__x); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type 
-    log2(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return log2(__type(__x));
-    }
-
-  inline float
-  logb(float __x)
-  { return __builtin_logbf(__x); }
-
-  inline long double
-  logb(long double __x)
-  { return __builtin_logbl(__x); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type 
-    logb(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return logb(__type(__x));
-    }
-
-  inline long
-  lrint(float __x)
-  { return __builtin_lrintf(__x); }
-
-  inline long
-  lrint(long double __x)
-  { return __builtin_lrintl(__x); }
-
-  template<typename _Tp>
-    inline long
-    lrint(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return lrint(__type(__x));
-    }
-
-  inline long
-  lround(float __x)
-  { return __builtin_lroundf(__x); }
-
-  inline long
-  lround(long double __x)
-  { return __builtin_lroundl(__x); }
-
-  template<typename _Tp>
-    inline long
-    lround(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return lround(__type(__x));
-    }
-
-  inline float
-  nearbyint(float __x)
-  { return __builtin_nearbyintf(__x); }
-
-  inline long double
-  nearbyint(long double __x)
-  { return __builtin_nearbyintl(__x); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type 
-    nearbyint(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return nearbyint(__type(__x));
-    }
-
-  inline float
-  nextafter(float __x, float __y)
-  { return __builtin_nextafterf(__x, __y); }
-
-  inline long double
-  nextafter(long double __x, long double __y)
-  { return __builtin_nextafterl(__x, __y); }
-
-  template<typename _Tp, typename _Up>
-    inline typename __promote_2<_Tp, _Up>::__type
-    nextafter(_Tp __x, _Up __y)
-    {
-      typedef typename __promote_2<_Tp, _Up>::__type __type;
-      return nextafter(__type(__x), __type(__y));
-    }
-
-  inline float
-  nexttoward(float __x, long double __y)
-  { return __builtin_nexttowardf(__x, __y); }
-
-  inline long double
-  nexttoward(long double __x, long double __y)
-  { return __builtin_nexttowardl(__x, __y); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type
-    nexttoward(_Tp __x, long double __y)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return nexttoward(__type(__x), __y);
-    }
-
-  using std::pow;
-
-  // DR 550.
-  template<typename _Tp, typename _Up>
-    inline typename __promote_2<_Tp, _Up>::__type
-    pow(_Tp __x, _Up __y)
-    {
-      typedef typename __promote_2<_Tp, _Up>::__type __type;
-      return pow(__type(__x), __type(__y));
-    }
-
-  inline float
-  remainder(float __x, float __y)
-  { return __builtin_remainderf(__x, __y); }
-
-  inline long double
-  remainder(long double __x, long double __y)
-  { return __builtin_remainderl(__x, __y); }
-
-  template<typename _Tp, typename _Up>
-    inline typename __promote_2<_Tp, _Up>::__type
-    remainder(_Tp __x, _Up __y)
-    {
-      typedef typename __promote_2<_Tp, _Up>::__type __type;
-      return remainder(__type(__x), __type(__y));
-    }
-
-  inline float
-  remquo(float __x, float __y, int* __pquo)
-  { return __builtin_remquof(__x, __y, __pquo); }
-
-  inline long double
-  remquo(long double __x, long double __y, int* __pquo)
-  { return __builtin_remquol(__x, __y, __pquo); }
-
-  template<typename _Tp, typename _Up>
-    inline typename __promote_2<_Tp, _Up>::__type
-    remquo(_Tp __x, _Up __y, int* __pquo)
-    {
-      typedef typename __promote_2<_Tp, _Up>::__type __type;
-      return remquo(__type(__x), __type(__y), __pquo);
-    }
-
-  inline float
-  rint(float __x)
-  { return __builtin_rintf(__x); }
-
-  inline long double
-  rint(long double __x)
-  { return __builtin_rintl(__x); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type
-    rint(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return rint(__type(__x));
-    }
-
-  inline float
-  round(float __x)
-  { return __builtin_roundf(__x); }
-
-  inline long double
-  round(long double __x)
-  { return __builtin_roundl(__x); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type
-    round(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return round(__type(__x));
-    }
-
-  inline float
-  scalbln(float __x, long __ex)
-  { return __builtin_scalblnf(__x, __ex); }
-
-  inline long double
-  scalbln(long double __x, long __ex)
-  { return __builtin_scalblnl(__x, __ex); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type 
-    scalbln(_Tp __x, long __ex)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return scalbln(__type(__x), __ex);
-    }
- 
-  inline float
-  scalbn(float __x, int __ex)
-  { return __builtin_scalbnf(__x, __ex); }
-
-  inline long double
-  scalbn(long double __x, int __ex)
-  { return __builtin_scalbnl(__x, __ex); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type 
-    scalbn(_Tp __x, int __ex)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return scalbn(__type(__x), __ex);
-    }
-
-  using std::sin;
-  using std::sinh;
-  using std::sqrt;
-  using std::tan;
-  using std::tanh;
-
-  inline float
-  tgamma(float __x)
-  { return __builtin_tgammaf(__x); }
-
-  inline long double
-  tgamma(long double __x)
-  { return __builtin_tgammal(__x); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type 
-    tgamma(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return tgamma(__type(__x));
-    }
- 
-  inline float
-  trunc(float __x)
-  { return __builtin_truncf(__x); }
-
-  inline long double
-  trunc(long double __x)
-  { return __builtin_truncl(__x); }
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type 
-    trunc(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return trunc(__type(__x));
-    }
-
+#include <cmath>
+#include <ext/type_traits.h>
+#include <tr1/type_traits>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/cmath>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/cmath>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
 #endif
 
-_GLIBCXX_END_NAMESPACE
-}
-
-
 /**
  * @defgroup tr1_math_spec_func Mathematical Special Functions
  * A collection of advanced mathematical special functions.
  * @{
  */
 #ifndef __GXX_EXPERIMENTAL_CXX0X__
+#include <bits/stl_algobase.h>
+#include <limits>
+
 #include <tr1/gamma.tcc>
 #include <tr1/bessel_function.tcc>
 #include <tr1/beta_function.tcc>
@@ -965,8 +82,8 @@ _GLIBCXX_END_NAMESPACE
 // namespace std::tr1
 namespace std
 {
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
+namespace tr1
+{
   //  5.2.1.1  Associated Laguerre polynomials.
 
   inline float
@@ -980,10 +97,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   }
 
   template<typename _Tp>
-    inline typename __promote<_Tp>::__type
+    inline typename __gnu_cxx::__promote<_Tp>::__type
     assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
     {
-      typedef typename __promote<_Tp>::__type __type;
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
       return __detail::__assoc_laguerre<__type>(__n, __m, __x);
     }
 
@@ -999,10 +116,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__assoc_legendre_p<long double>(__l, __m, __x); }
 
   template<typename _Tp>
-    inline typename __promote<_Tp>::__type
+    inline typename __gnu_cxx::__promote<_Tp>::__type
     assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x)
     {
-      typedef typename __promote<_Tp>::__type __type;
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
       return __detail::__assoc_legendre_p<__type>(__l, __m, __x);
     }
 
@@ -1018,10 +135,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__beta<long double>(__x, __y); }
 
   template<typename _Tpx, typename _Tpy>
-    inline typename __promote_2<_Tpx, _Tpy>::__type
+    inline typename __gnu_cxx::__promote_2<_Tpx, _Tpy>::__type
     beta(_Tpx __x, _Tpy __y)
     {
-      typedef typename __promote_2<_Tpx, _Tpy>::__type __type;
+      typedef typename __gnu_cxx::__promote_2<_Tpx, _Tpy>::__type __type;
       return __detail::__beta<__type>(__x, __y);
     }
 
@@ -1037,10 +154,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__comp_ellint_1<long double>(__k); }
 
   template<typename _Tp>
-    inline typename __promote<_Tp>::__type
+    inline typename __gnu_cxx::__promote<_Tp>::__type
     comp_ellint_1(_Tp __k)
     {
-      typedef typename __promote<_Tp>::__type __type;
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
       return __detail::__comp_ellint_1<__type>(__k);
     }
 
@@ -1056,10 +173,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__comp_ellint_2<long double>(__k); }
 
   template<typename _Tp>
-    inline typename __promote<_Tp>::__type
+    inline typename __gnu_cxx::__promote<_Tp>::__type
     comp_ellint_2(_Tp __k)
     {
-      typedef typename __promote<_Tp>::__type __type;
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
       return __detail::__comp_ellint_2<__type>(__k);
     }
 
@@ -1075,10 +192,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__comp_ellint_3<long double>(__k, __nu); }
 
   template<typename _Tp, typename _Tpn>
-    inline typename __promote_2<_Tp, _Tpn>::__type
+    inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type
     comp_ellint_3(_Tp __k, _Tpn __nu)
     {
-      typedef typename __promote_2<_Tp, _Tpn>::__type __type;
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type;
       return __detail::__comp_ellint_3<__type>(__k, __nu);
     }
 
@@ -1094,10 +211,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__conf_hyperg<long double>(__a, __c, __x); }
 
   template<typename _Tpa, typename _Tpc, typename _Tp>
-    inline typename __promote_3<_Tpa, _Tpc, _Tp>::__type
+    inline typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type
     conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x)
     {
-      typedef typename __promote_3<_Tpa, _Tpc, _Tp>::__type __type;
+      typedef typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type __type;
       return __detail::__conf_hyperg<__type>(__a, __c, __x);
     }
 
@@ -1113,10 +230,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__cyl_bessel_i<long double>(__nu, __x); }
 
   template<typename _Tpnu, typename _Tp>
-    inline typename __promote_2<_Tpnu, _Tp>::__type
+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
     cyl_bessel_i(_Tpnu __nu, _Tp __x)
     {
-      typedef typename __promote_2<_Tpnu, _Tp>::__type __type;
+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
       return __detail::__cyl_bessel_i<__type>(__nu, __x);
     }
 
@@ -1132,10 +249,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__cyl_bessel_j<long double>(__nu, __x); }
 
   template<typename _Tpnu, typename _Tp>
-    inline typename __promote_2<_Tpnu, _Tp>::__type
+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
     cyl_bessel_j(_Tpnu __nu, _Tp __x)
     {
-      typedef typename __promote_2<_Tpnu, _Tp>::__type __type;
+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
       return __detail::__cyl_bessel_j<__type>(__nu, __x);
     }
 
@@ -1151,10 +268,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__cyl_bessel_k<long double>(__nu, __x); }
 
   template<typename _Tpnu, typename _Tp>
-    inline typename __promote_2<_Tpnu, _Tp>::__type
+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
     cyl_bessel_k(_Tpnu __nu, _Tp __x)
     {
-      typedef typename __promote_2<_Tpnu, _Tp>::__type __type;
+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
       return __detail::__cyl_bessel_k<__type>(__nu, __x);
     }
 
@@ -1170,10 +287,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__cyl_neumann_n<long double>(__nu, __x); }
 
   template<typename _Tpnu, typename _Tp>
-    inline typename __promote_2<_Tpnu, _Tp>::__type
+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
     cyl_neumann(_Tpnu __nu, _Tp __x)
     {
-      typedef typename __promote_2<_Tpnu, _Tp>::__type __type;
+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
       return __detail::__cyl_neumann_n<__type>(__nu, __x);
     }
 
@@ -1189,10 +306,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__ellint_1<long double>(__k, __phi); }
 
   template<typename _Tp, typename _Tpp>
-    inline typename __promote_2<_Tp, _Tpp>::__type
+    inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
     ellint_1(_Tp __k, _Tpp __phi)
     {
-      typedef typename __promote_2<_Tp, _Tpp>::__type __type;
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
       return __detail::__ellint_1<__type>(__k, __phi);
     }
 
@@ -1208,10 +325,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__ellint_2<long double>(__k, __phi); }
 
   template<typename _Tp, typename _Tpp>
-    inline typename __promote_2<_Tp, _Tpp>::__type
+    inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
     ellint_2(_Tp __k, _Tpp __phi)
     {
-      typedef typename __promote_2<_Tp, _Tpp>::__type __type;
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
       return __detail::__ellint_2<__type>(__k, __phi);
     }
 
@@ -1227,10 +344,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__ellint_3<long double>(__k, __nu, __phi); }
 
   template<typename _Tp, typename _Tpn, typename _Tpp>
-    inline typename __promote_3<_Tp, _Tpn, _Tpp>::__type
+    inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type
     ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi)
     {
-      typedef typename __promote_3<_Tp, _Tpn, _Tpp>::__type __type;
+      typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type;
       return __detail::__ellint_3<__type>(__k, __nu, __phi);
     }
 
@@ -1246,10 +363,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__expint<long double>(__x); }
 
   template<typename _Tp>
-    inline typename __promote<_Tp>::__type
+    inline typename __gnu_cxx::__promote<_Tp>::__type
     expint(_Tp __x)
     {
-      typedef typename __promote<_Tp>::__type __type;
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
       return __detail::__expint<__type>(__x);
     }
 
@@ -1265,10 +382,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__poly_hermite<long double>(__n, __x); }
 
   template<typename _Tp>
-    inline typename __promote<_Tp>::__type
+    inline typename __gnu_cxx::__promote<_Tp>::__type
     hermite(unsigned int __n, _Tp __x)
     {
-      typedef typename __promote<_Tp>::__type __type;
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
       return __detail::__poly_hermite<__type>(__n, __x);
     }
 
@@ -1284,10 +401,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__hyperg<long double>(__a, __b, __c, __x); }
 
   template<typename _Tpa, typename _Tpb, typename _Tpc, typename _Tp>
-    inline typename __promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type
+    inline typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type
     hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x)
     {
-      typedef typename __promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type __type;
+      typedef typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type __type;
       return __detail::__hyperg<__type>(__a, __b, __c, __x);
     }
 
@@ -1303,10 +420,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__laguerre<long double>(__n, __x); }
 
   template<typename _Tp>
-    inline typename __promote<_Tp>::__type
+    inline typename __gnu_cxx::__promote<_Tp>::__type
     laguerre(unsigned int __n, _Tp __x)
     {
-      typedef typename __promote<_Tp>::__type __type;
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
       return __detail::__laguerre<__type>(__n, __x);
     }
 
@@ -1322,10 +439,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__poly_legendre_p<long double>(__n, __x); }
 
   template<typename _Tp>
-    inline typename __promote<_Tp>::__type
+    inline typename __gnu_cxx::__promote<_Tp>::__type
     legendre(unsigned int __n, _Tp __x)
     {
-      typedef typename __promote<_Tp>::__type __type;
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
       return __detail::__poly_legendre_p<__type>(__n, __x);
     }
 
@@ -1341,10 +458,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__riemann_zeta<long double>(__x); }
 
   template<typename _Tp>
-    inline typename __promote<_Tp>::__type
+    inline typename __gnu_cxx::__promote<_Tp>::__type
     riemann_zeta(_Tp __x)
     {
-      typedef typename __promote<_Tp>::__type __type;
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
       return __detail::__riemann_zeta<__type>(__x);
     }
 
@@ -1360,10 +477,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__sph_bessel<long double>(__n, __x); }
 
   template<typename _Tp>
-    inline typename __promote<_Tp>::__type
+    inline typename __gnu_cxx::__promote<_Tp>::__type
     sph_bessel(unsigned int __n, _Tp __x)
     {
-      typedef typename __promote<_Tp>::__type __type;
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
       return __detail::__sph_bessel<__type>(__n, __x);
     }
 
@@ -1379,10 +496,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__sph_legendre<long double>(__l, __m, __theta); }
 
   template<typename _Tp>
-    inline typename __promote<_Tp>::__type
+    inline typename __gnu_cxx::__promote<_Tp>::__type
     sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
     {
-      typedef typename __promote<_Tp>::__type __type;
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
       return __detail::__sph_legendre<__type>(__l, __m, __theta);
     }
 
@@ -1398,18 +515,18 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   { return __detail::__sph_neumann<long double>(__n, __x); }
 
   template<typename _Tp>
-    inline typename __promote<_Tp>::__type
+    inline typename __gnu_cxx::__promote<_Tp>::__type
     sph_neumann(unsigned int __n, _Tp __x)
     {
-      typedef typename __promote<_Tp>::__type __type;
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
       return __detail::__sph_neumann<__type>(__n, __x);
     }
 
   /* @} */ // group tr1_math_spec_func
 
-_GLIBCXX_END_NAMESPACE
+}
 }
 
 #endif // __GXX_EXPERIMENTAL_CXX0X__
 
-#endif
+#endif // _GLIBCXX_TR1_CMATH
diff --git a/libstdc++-v3/include/tr1/common.h b/libstdc++-v3/include/tr1/common.h
deleted file mode 100644
index d26fdd6..0000000
--- a/libstdc++-v3/include/tr1/common.h
+++ /dev/null
@@ -1,91 +0,0 @@
-// Internal header for TR1 complex -*- C++ -*-
-
-// Copyright (C) 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 2, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License along
-// with this library; see the file COPYING.  If not, write to the Free
-// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
-// USA.
-
-// As a special exception, you may use this file as part of a free software
-// library without restriction.  Specifically, if other files instantiate
-// templates or use macros or inline functions from this file, or you compile
-// this file and link it with other files to produce an executable, this
-// file does not by itself cause the resulting executable to be covered by
-// the GNU General Public License.  This exception does not however
-// invalidate any other reasons why the executable file might be covered by
-// the GNU General Public License.
-
-/** @file tr1/common.h
- *  This is a TR1 C++ Library header. 
- */
-
-#ifndef _TR1_COMMON_H
-#define _TR1_COMMON_H 1
-
-#include <tr1/type_traits>
-
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-  template<typename _Tp, bool = is_integral<_Tp>::value>
-    struct __promote
-    { typedef double __type; };
-
-  template<typename _Tp>
-    struct __promote<_Tp, false>
-    { typedef _Tp __type; };
-
-  template<typename _Tp, typename _Up>
-    struct __promote_2
-    {
-    private:
-      typedef typename __promote<_Tp>::__type __type1;
-      typedef typename __promote<_Up>::__type __type2;
-
-    public:
-      typedef __typeof__(__type1() + __type2()) __type;
-    };
-
-  template<typename _Tp, typename _Up, typename _Vp>
-    struct __promote_3
-    {
-    private:
-      typedef typename __promote<_Tp>::__type __type1;
-      typedef typename __promote<_Up>::__type __type2;
-      typedef typename __promote<_Vp>::__type __type3;
-
-    public:
-      typedef __typeof__(__type1() + __type2() + __type3()) __type;
-    };
-
-  template<typename _Tp, typename _Up, typename _Vp, typename _Wp>
-    struct __promote_4
-    {
-    private:
-      typedef typename __promote<_Tp>::__type __type1;
-      typedef typename __promote<_Up>::__type __type2;
-      typedef typename __promote<_Vp>::__type __type3;
-      typedef typename __promote<_Wp>::__type __type4;
-
-    public:
-      typedef __typeof__(__type1() + __type2() + __type3() + __type4()) __type;
-    };
-
-_GLIBCXX_END_NAMESPACE
-} // namespace std
-
-#endif
diff --git a/libstdc++-v3/include/tr1/complex b/libstdc++-v3/include/tr1/complex
index 666cae9..ef21129 100644
--- a/libstdc++-v3/include/tr1/complex
+++ b/libstdc++-v3/include/tr1/complex
@@ -31,379 +31,46 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_COMPLEX
-#define _TR1_COMPLEX 1
+#ifndef _GLIBCXX_TR1_COMPLEX
+#define _GLIBCXX_TR1_COMPLEX 1
 
-#include <complex>
-#include <tr1/common.h>
-
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-  // Forward declarations.
-  template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
-  template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
-  template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
-
-  template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
-  template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
-  template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
-  template<typename _Tp> std::complex<_Tp> fabs(const std::complex<_Tp>&);
-
-  /// @brief acos(__z) [8.1.2].
-  //  Effects:  Behaves the same as C99 function cacos, defined
-  //            in subclause 7.3.5.1.
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    __complex_acos(const std::complex<_Tp>& __z)
-    {
-      const std::complex<_Tp> __t = std::_GLIBCXX_TR1::asin(__z);
-      const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
-      return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
-    }
-
-#if _GLIBCXX_USE_C99_COMPLEX_TR1
-  inline __complex__ float
-  __complex_acos(__complex__ float __z)
-  { return __builtin_cacosf(__z); }
-
-  inline __complex__ double
-  __complex_acos(__complex__ double __z)
-  { return __builtin_cacos(__z); }
-
-  inline __complex__ long double
-  __complex_acos(const __complex__ long double& __z)
-  { return __builtin_cacosl(__z); }
-
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    acos(const std::complex<_Tp>& __z)
-    { return __complex_acos(__z.__rep()); }
-#else
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    acos(const std::complex<_Tp>& __z)
-    { return __complex_acos(__z); }
-#endif
-
-  /// @brief asin(__z) [8.1.3].
-  //  Effects:  Behaves the same as C99 function casin, defined
-  //            in subclause 7.3.5.2.
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    __complex_asin(const std::complex<_Tp>& __z)
-    {
-      std::complex<_Tp> __t(-__z.imag(), __z.real());
-      __t = std::_GLIBCXX_TR1::asinh(__t);
-      return std::complex<_Tp>(__t.imag(), -__t.real());
-    }
-
-#if _GLIBCXX_USE_C99_COMPLEX_TR1
-  inline __complex__ float
-  __complex_asin(__complex__ float __z)
-  { return __builtin_casinf(__z); }
-
-  inline __complex__ double
-  __complex_asin(__complex__ double __z)
-  { return __builtin_casin(__z); }
-
-  inline __complex__ long double
-  __complex_asin(const __complex__ long double& __z)
-  { return __builtin_casinl(__z); }
-
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    asin(const std::complex<_Tp>& __z)
-    { return __complex_asin(__z.__rep()); }
-#else
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    asin(const std::complex<_Tp>& __z)
-    { return __complex_asin(__z); }
-#endif
-  
-  /// @brief atan(__z) [8.1.4].
-  //  Effects:  Behaves the same as C99 function catan, defined
-  //            in subclause 7.3.5.3.
-  template<typename _Tp>
-    std::complex<_Tp>
-    __complex_atan(const std::complex<_Tp>& __z)
-    {
-      const _Tp __r2 = __z.real() * __z.real();
-      const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
-
-      _Tp __num = __z.imag() + _Tp(1.0);
-      _Tp __den = __z.imag() - _Tp(1.0);
-
-      __num = __r2 + __num * __num;
-      __den = __r2 + __den * __den;
-
-      return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
-			       _Tp(0.25) * log(__num / __den));
-    }
-
-#if _GLIBCXX_USE_C99_COMPLEX_TR1
-  inline __complex__ float
-  __complex_atan(__complex__ float __z)
-  { return __builtin_catanf(__z); }
-
-  inline __complex__ double
-  __complex_atan(__complex__ double __z)
-  { return __builtin_catan(__z); }
-
-  inline __complex__ long double
-  __complex_atan(const __complex__ long double& __z)
-  { return __builtin_catanl(__z); }
-
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    atan(const std::complex<_Tp>& __z)
-    { return __complex_atan(__z.__rep()); }
-#else
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    atan(const std::complex<_Tp>& __z)
-    { return __complex_atan(__z); }
-#endif
-
-  /// @brief acosh(__z) [8.1.5].
-  //  Effects:  Behaves the same as C99 function cacosh, defined
-  //            in subclause 7.3.6.1.
-  template<typename _Tp>
-    std::complex<_Tp>
-    __complex_acosh(const std::complex<_Tp>& __z)
-    {
-      std::complex<_Tp> __t((__z.real() - __z.imag())
-			    * (__z.real() + __z.imag()) - _Tp(1.0),
-			    _Tp(2.0) * __z.real() * __z.imag());
-      __t = std::sqrt(__t);
-
-      return std::log(__t + __z);
-    }
-
-#if _GLIBCXX_USE_C99_COMPLEX_TR1
-  inline __complex__ float
-  __complex_acosh(__complex__ float __z)
-  { return __builtin_cacoshf(__z); }
-
-  inline __complex__ double
-  __complex_acosh(__complex__ double __z)
-  { return __builtin_cacosh(__z); }
-
-  inline __complex__ long double
-  __complex_acosh(const __complex__ long double& __z)
-  { return __builtin_cacoshl(__z); }
-
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    acosh(const std::complex<_Tp>& __z)
-    { return __complex_acosh(__z.__rep()); }
-#else
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    acosh(const std::complex<_Tp>& __z)
-    { return __complex_acosh(__z); }
-#endif
-
-  /// @brief asinh(__z) [8.1.6].
-  //  Effects:  Behaves the same as C99 function casin, defined
-  //            in subclause 7.3.6.2.
-  template<typename _Tp>
-    std::complex<_Tp>
-    __complex_asinh(const std::complex<_Tp>& __z)
-    {
-      std::complex<_Tp> __t((__z.real() - __z.imag())
-			    * (__z.real() + __z.imag()) + _Tp(1.0),
-			    _Tp(2.0) * __z.real() * __z.imag());
-      __t = std::sqrt(__t);
+#pragma GCC system_header
 
-      return std::log(__t + __z);
-    }
-
-#if _GLIBCXX_USE_C99_COMPLEX_TR1
-  inline __complex__ float
-  __complex_asinh(__complex__ float __z)
-  { return __builtin_casinhf(__z); }
-
-  inline __complex__ double
-  __complex_asinh(__complex__ double __z)
-  { return __builtin_casinh(__z); }
-
-  inline __complex__ long double
-  __complex_asinh(const __complex__ long double& __z)
-  { return __builtin_casinhl(__z); }
-
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    asinh(const std::complex<_Tp>& __z)
-    { return __complex_asinh(__z.__rep()); }
-#else
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    asinh(const std::complex<_Tp>& __z)
-    { return __complex_asinh(__z); }
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
 #endif
 
-  /// @brief atanh(__z) [8.1.7].
-  //  Effects:  Behaves the same as C99 function catanh, defined
-  //            in subclause 7.3.6.3.
-  template<typename _Tp>
-    std::complex<_Tp>
-    __complex_atanh(const std::complex<_Tp>& __z)
-    {
-      const _Tp __i2 = __z.imag() * __z.imag();
-      const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
-
-      _Tp __num = _Tp(1.0) + __z.real();
-      _Tp __den = _Tp(1.0) - __z.real();
-
-      __num = __i2 + __num * __num;
-      __den = __i2 + __den * __den;
-
-      return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
-			       _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
-    }
-
-#if _GLIBCXX_USE_C99_COMPLEX_TR1
-  inline __complex__ float
-  __complex_atanh(__complex__ float __z)
-  { return __builtin_catanhf(__z); }
-
-  inline __complex__ double
-  __complex_atanh(__complex__ double __z)
-  { return __builtin_catanh(__z); }
-
-  inline __complex__ long double
-  __complex_atanh(const __complex__ long double& __z)
-  { return __builtin_catanhl(__z); }
+#include <complex>
+#include <ext/type_traits.h>
+#include <tr1/type_traits>
 
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    atanh(const std::complex<_Tp>& __z)
-    { return __complex_atanh(__z.__rep()); }
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/complex>
 #else
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    atanh(const std::complex<_Tp>& __z)
-    { return __complex_atanh(__z); }
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/complex>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
 #endif
 
-  /// @brief fabs(__z) [8.1.8].
-  //  Effects:  Behaves the same as C99 function cabs, defined
-  //            in subclause 7.3.8.1.
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    fabs(const std::complex<_Tp>& __z)
-    { return std::abs(__z); }
-
-
-  /// @brief Additional overloads [8.1.9].
-  //
-
-  // See common.h for the primary template.
-  template<typename _Tp, typename _Up>
-    struct __promote_2<std::complex<_Tp>, _Up>
-    {
-    public:
-      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
-    };
-
-  template<typename _Tp, typename _Up>
-    struct __promote_2<_Tp, std::complex<_Up> >
-    {
-    public:
-      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
-    };
-  
-  template<typename _Tp, typename _Up>
-    struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
-    {
-    public:
-      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
-    };
-
-
+namespace std
+{
+namespace tr1
+{
   using std::arg;
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type
-    arg(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return std::arg(std::complex<__type>(__x));
-    }
-
   using std::conj;
-
-  template<typename _Tp>
-    inline std::complex<typename __promote<_Tp>::__type>
-    conj(_Tp __x)
-    { return __x; }
-
   using std::imag;
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type
-    imag(_Tp)
-    { return _Tp(); }
-
   using std::norm;
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type
-    norm(_Tp __x)
-    {
-      typedef typename __promote<_Tp>::__type __type;
-      return __type(__x) * __type(__x);
-    }
-
   using std::polar;
-
-  template<typename _Tp, typename _Up>
-    inline std::complex<typename __promote_2<_Tp, _Up>::__type>
-    polar(const _Tp& __rho, const _Up& __theta)
-    {
-      typedef typename __promote_2<_Tp, _Up>::__type __type;
-      return std::polar(__type(__rho), __type(__theta));
-    }
-  
   using std::pow;
-  
-  template<typename _Tp, typename _Up>
-    inline std::complex<typename __promote_2<_Tp, _Up>::__type>
-    pow(const std::complex<_Tp>& __x, const _Up& __y)
-    {
-      typedef typename __promote_2<_Tp, _Up>::__type __type;
-      return std::pow(std::complex<__type>(__x), __type(__y));
-    }
-
-  template<typename _Tp, typename _Up>
-    inline std::complex<typename __promote_2<_Tp, _Up>::__type>
-    pow(const _Tp& __x, const std::complex<_Up>& __y)
-    {
-      typedef typename __promote_2<_Tp, _Up>::__type __type;
-      return std::pow(__type(__x), std::complex<__type>(__y));
-    }
-
-  template<typename _Tp, typename _Up>
-    inline std::complex<typename __promote_2<_Tp, _Up>::__type>
-    pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
-    {
-      typedef typename __promote_2<_Tp, _Up>::__type __type;
-      return std::pow(std::complex<__type>(__x),
-		      std::complex<__type>(__y));
-    }
-
   using std::real;
-
-  template<typename _Tp>
-    inline typename __promote<_Tp>::__type
-    real(_Tp __x)
-    { return __x; }
-
-_GLIBCXX_END_NAMESPACE
+}
 }
 
-#endif
+#endif // _GLIBCXX_TR1_COMPLEX
+
diff --git a/libstdc++-v3/include/tr1/complex.h b/libstdc++-v3/include/tr1/complex.h
index 12fadec..ad0c77d 100644
--- a/libstdc++-v3/include/tr1/complex.h
+++ b/libstdc++-v3/include/tr1/complex.h
@@ -31,9 +31,9 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_COMPLEX_H
-#define _TR1_COMPLEX_H 1
+#ifndef _GLIBCXX_TR1_COMPLEX_H
+#define _GLIBCXX_TR1_COMPLEX_H 1
 
 #include <tr1/ccomplex>
 
-#endif
+#endif // _GLIBCXX_TR1_COMPLEX_H
diff --git a/libstdc++-v3/include/tr1/cstdarg b/libstdc++-v3/include/tr1/cstdarg
index e70130e..20629e7 100644
--- a/libstdc++-v3/include/tr1/cstdarg
+++ b/libstdc++-v3/include/tr1/cstdarg
@@ -1,6 +1,6 @@
 // TR1 cstdarg -*- C++ -*-
 
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -31,9 +31,9 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_CSTDARG
-#define _TR1_CSTDARG 1
+#ifndef _GLIBCXX_TR1_CSTDARG
+#define _GLIBCXX_TR1_CSTDARG 1
 
 #include <cstdarg>
 
-#endif
+#endif // _GLIBCXX_TR1_CSTDARG
diff --git a/libstdc++-v3/include/tr1/cstdbool b/libstdc++-v3/include/tr1/cstdbool
index 939f2c7..4e43db3 100644
--- a/libstdc++-v3/include/tr1/cstdbool
+++ b/libstdc++-v3/include/tr1/cstdbool
@@ -31,8 +31,8 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_CSTDBOOL
-#define _TR1_CSTDBOOL 1
+#ifndef _GLIBCXX_TR1_CSTDBOOL
+#define _GLIBCXX_TR1_CSTDBOOL 1
 
 #include <bits/c++config.h>
 
@@ -40,4 +40,4 @@
 #include_next <stdbool.h>
 #endif
 
-#endif
+#endif // _GLIBCXX_TR1_CSTDBOOL
diff --git a/libstdc++-v3/include/tr1/cstdint b/libstdc++-v3/include/tr1/cstdint
index 56fa308..6f7ac76 100644
--- a/libstdc++-v3/include/tr1/cstdint
+++ b/libstdc++-v3/include/tr1/cstdint
@@ -31,62 +31,30 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_CSTDINT
-#define _TR1_CSTDINT 1
+#ifndef _GLIBCXX_TR1_CSTDINT
+#define _GLIBCXX_TR1_CSTDINT 1
 
-#include <bits/c++config.h>
-
-#if _GLIBCXX_USE_C99_STDINT_TR1
-
-// For 8.22.1/1 (see C99, Notes 219, 220, 222) 
-#define __STDC_LIMIT_MACROS
-#define __STDC_CONSTANT_MACROS
-#include_next <stdint.h>
-
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-  using ::int8_t;
-  using ::int16_t;
-  using ::int32_t;
-  using ::int64_t;
-
-  using ::int_fast8_t;
-  using ::int_fast16_t;
-  using ::int_fast32_t;
-  using ::int_fast64_t;
-
-  using ::int_least8_t;
-  using ::int_least16_t;
-  using ::int_least32_t;
-  using ::int_least64_t;
+#pragma GCC system_header
 
-  using ::intmax_t;
-  using ::intptr_t;
-  
-  using ::uint8_t;
-  using ::uint16_t;
-  using ::uint32_t;
-  using ::uint64_t;
-
-  using ::uint_fast8_t;
-  using ::uint_fast16_t;
-  using ::uint_fast32_t;
-  using ::uint_fast64_t;
-
-  using ::uint_least8_t;
-  using ::uint_least16_t;
-  using ::uint_least32_t;
-  using ::uint_least64_t;
-
-  using ::uintmax_t;
-  using ::uintptr_t;
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
 
-_GLIBCXX_END_NAMESPACE
-}
+#include <bits/c++config.h>
 
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/cstdint>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/cstdint>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
 #endif
 
-#endif
+#endif // _GLIBCXX_TR1_CSTDINT
+
diff --git a/libstdc++-v3/include/tr1/cstdio b/libstdc++-v3/include/tr1/cstdio
index b016a15..ddb1867 100644
--- a/libstdc++-v3/include/tr1/cstdio
+++ b/libstdc++-v3/include/tr1/cstdio
@@ -31,27 +31,29 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_CSTDIO
-#define _TR1_CSTDIO 1
+#ifndef _GLIBCXX_TR1_CSTDIO
+#define _GLIBCXX_TR1_CSTDIO 1
 
-#include <bits/c++config.h>
-#include <cstdio>
-
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-#if _GLIBCXX_USE_C99
-  using std::snprintf;
-  using std::vsnprintf;
+#pragma GCC system_header
 
-  using std::vfscanf;
-  using std::vscanf;
-  using std::vsscanf;
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
 #endif
 
-_GLIBCXX_END_NAMESPACE
-}
+#include <cstdio>
 
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/cstdio>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/cstdio>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
 #endif
+
+#endif // _GLIBCXX_TR1_CSTDIO
diff --git a/libstdc++-v3/include/tr1/cstdlib b/libstdc++-v3/include/tr1/cstdlib
index 5096fa8..acacbcd 100644
--- a/libstdc++-v3/include/tr1/cstdlib
+++ b/libstdc++-v3/include/tr1/cstdlib
@@ -31,49 +31,29 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_CSTDLIB
-#define _TR1_CSTDLIB 1
+#ifndef _GLIBCXX_TR1_CSTDLIB
+#define _GLIBCXX_TR1_CSTDLIB 1
 
-#include <bits/c++config.h>
+#pragma GCC system_header
 
-#if _GLIBCXX_HOSTED
-
-#include <cstdlib>
-
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-#if _GLIBCXX_USE_C99
-
-#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
-  // types
-  using std::lldiv_t;
-
-  // functions
-  using std::llabs;
-  using std::lldiv;
-#endif
-
-  using std::atoll;
-  using std::strtoll;
-  using std::strtoull;
-
-  using std::strtof;
-  using std::strtold;
-
-  // overloads
-  using std::abs;
-#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
-  using std::div;
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
 #endif
 
-#endif
-
-_GLIBCXX_END_NAMESPACE
-}
+#include <cstdlib>
 
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/cstdlib>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/cstdlib>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
 #endif
 
-#endif
+#endif // _GLIBCXX_TR1_CSTDLIB
diff --git a/libstdc++-v3/include/tr1/ctgmath b/libstdc++-v3/include/tr1/ctgmath
index eb91185..2f6af68 100644
--- a/libstdc++-v3/include/tr1/ctgmath
+++ b/libstdc++-v3/include/tr1/ctgmath
@@ -1,6 +1,6 @@
 // TR1 ctgmath -*- C++ -*-
 
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -31,9 +31,9 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_CTGMATH
-#define _TR1_CTGMATH 1
+#ifndef _GLIBCXX_TR1_CTGMATH
+#define _GLIBCXX_TR1_CTGMATH 1
 
 #include <tr1/cmath>
 
-#endif
+#endif // _GLIBCXX_TR1_CTGMATH
diff --git a/libstdc++-v3/include/tr1/ctime b/libstdc++-v3/include/tr1/ctime
index 45e0839..4c14cca 100644
--- a/libstdc++-v3/include/tr1/ctime
+++ b/libstdc++-v3/include/tr1/ctime
@@ -1,6 +1,6 @@
 // TR1 ctime -*- C++ -*-
 
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -31,9 +31,9 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_CTIME
-#define _TR1_CTIME 1
+#ifndef _GLIBCXX_TR1_CTIME
+#define _GLIBCXX_TR1_CTIME 1
 
 #include <ctime>
 
-#endif
+#endif // _GLIBCXX_TR1_CTIME
diff --git a/libstdc++-v3/include/tr1/cwchar b/libstdc++-v3/include/tr1/cwchar
index abc88bb..c6fb88e 100644
--- a/libstdc++-v3/include/tr1/cwchar
+++ b/libstdc++-v3/include/tr1/cwchar
@@ -1,6 +1,6 @@
 // TR1 cwchar -*- C++ -*-
 
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -31,42 +31,29 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_CWCHAR
-#define _TR1_CWCHAR 1
+#ifndef _GLIBCXX_TR1_CWCHAR
+#define _GLIBCXX_TR1_CWCHAR 1
 
-#include <bits/c++config.h>
+#pragma GCC system_header
 
-#if _GLIBCXX_USE_WCHAR_T
-
-#include <cwchar>
-
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-#if _GLIBCXX_HAVE_WCSTOF
-  using std::wcstof;
-#endif
-#if _GLIBCXX_HAVE_VFWSCANF
-  using std::vfwscanf;
-#endif
-#if _GLIBCXX_HAVE_VSWSCANF
-  using std::vswscanf;
-#endif
-#if _GLIBCXX_HAVE_VWSCANF
-  using std::vwscanf;
-#endif
-
-#if _GLIBCXX_USE_C99
-  using std::wcstold;
-  using std::wcstoll;
-  using std::wcstoull;
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
 #endif
 
-_GLIBCXX_END_NAMESPACE
-}
+#include <cwchar>
 
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/cwchar>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/cwchar>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
 #endif
 
-#endif
+#endif // _GLIBCXX_TR1_CWCHAR
diff --git a/libstdc++-v3/include/tr1/cwctype b/libstdc++-v3/include/tr1/cwctype
index f6e99be..2b2b367 100644
--- a/libstdc++-v3/include/tr1/cwctype
+++ b/libstdc++-v3/include/tr1/cwctype
@@ -1,6 +1,6 @@
 // TR1 cwctype -*- C++ -*-
 
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -31,27 +31,29 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_CWCTYPE
-#define _TR1_CWCTYPE 1
+#ifndef _GLIBCXX_TR1_CWCTYPE
+#define _GLIBCXX_TR1_CWCTYPE 1
 
-#include <bits/c++config.h>
+#pragma GCC system_header
 
-#if _GLIBCXX_USE_WCHAR_T
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
 
 #include <cwctype>
 
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-#if _GLIBCXX_HAVE_ISWBLANK
-  using std::iswblank;
-#endif  
-
-_GLIBCXX_END_NAMESPACE
-}
-
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/cwctype>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/cwctype>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
 #endif
 
-#endif
+#endif // _GLIBCXX_TR1_CWCTYPE
diff --git a/libstdc++-v3/include/tr1/ell_integral.tcc b/libstdc++-v3/include/tr1/ell_integral.tcc
index 03cfefa..745b379 100644
--- a/libstdc++-v3/include/tr1/ell_integral.tcc
+++ b/libstdc++-v3/include/tr1/ell_integral.tcc
@@ -45,12 +45,13 @@
 //        W. T. Vetterling, B. P. Flannery, Cambridge University Press
 //        (1992), pp. 261-269
 
-#ifndef _TR1_ELL_INTEGRAL_TCC
-#define _TR1_ELL_INTEGRAL_TCC 1
+#ifndef _GLIBCXX_TR1_ELL_INTEGRAL_TCC
+#define _GLIBCXX_TR1_ELL_INTEGRAL_TCC 1
 
 namespace std
 {
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
 
   // [5.2] Special functions
 
@@ -755,8 +756,8 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 
   /* @} */ // group tr1_math_spec_func
 
-_GLIBCXX_END_NAMESPACE
+}
 }
 
-#endif // _TR1_ELL_INTEGRAL_TCC
+#endif // _GLIBCXX_TR1_ELL_INTEGRAL_TCC
 
diff --git a/libstdc++-v3/include/tr1/exp_integral.tcc b/libstdc++-v3/include/tr1/exp_integral.tcc
index d6acc72..fa016fc 100644
--- a/libstdc++-v3/include/tr1/exp_integral.tcc
+++ b/libstdc++-v3/include/tr1/exp_integral.tcc
@@ -48,14 +48,15 @@
 //       2nd ed, pp. 222-225.
 //
 
-#ifndef _TR1_EXP_INTEGRAL_TCC
-#define _TR1_EXP_INTEGRAL_TCC 1
+#ifndef _GLIBCXX_TR1_EXP_INTEGRAL_TCC
+#define _GLIBCXX_TR1_EXP_INTEGRAL_TCC 1
 
 #include "special_function_util.h"
 
 namespace std
 {
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
 
   // [5.2] Special functions
 
@@ -532,7 +533,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 
   /* @} */ // group tr1_math_spec_func
 
-_GLIBCXX_END_NAMESPACE
+}
 }
 
-#endif // _TR1_EXP_INTEGRAL_TCC
+#endif // _GLIBCXX_TR1_EXP_INTEGRAL_TCC
diff --git a/libstdc++-v3/include/tr1/functional b/libstdc++-v3/include/tr1/functional
index 1fcc0dc..d3afe76 100644
--- a/libstdc++-v3/include/tr1/functional
+++ b/libstdc++-v3/include/tr1/functional
@@ -31,2280 +31,38 @@
  *  This is a TR1 C++ Library header.
  */
 
-#ifndef _TR1_FUNCTIONAL
-#define _TR1_FUNCTIONAL 1
+#ifndef _GLIBCXX_TR1_FUNCTIONAL
+#define _GLIBCXX_TR1_FUNCTIONAL 1
 
 #pragma GCC system_header
 
-#include <cmath>                // for std::frexp
-#include <string>               // for std::tr1::hash
-#include <functional>
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
+
+#include <bits/c++config.h>
+#include <bits/stl_function.h>
+
+#include <cmath>
+#include <string>
 #include <typeinfo>
+#include <ext/type_traits.h>
 #include <tr1/tuple>
 #include <tr1/type_traits>
-#include <ext/type_traits.h>
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-  template<typename _MemberPointer>
-    class _Mem_fn;
-
-  /**
-   *  @if maint
-   *  Actual implementation of _Has_result_type, which uses SFINAE to
-   *  determine if the type _Tp has a publicly-accessible member type
-   *  result_type.
-   *  @endif
-  */
-  template<typename _Tp>
-    class _Has_result_type_helper : __sfinae_types
-    {
-      template<typename _Up>
-        struct _Wrap_type
-	{ };
-
-      template<typename _Up>
-        static __one __test(_Wrap_type<typename _Up::result_type>*);
-
-      template<typename _Up>
-        static __two __test(...);
-
-    public:
-      static const bool value = sizeof(__test<_Tp>(0)) == 1;
-    };
-
-  template<typename _Tp>
-    struct _Has_result_type
-    : integral_constant<bool,
-	      _Has_result_type_helper<typename remove_cv<_Tp>::type>::value>
-    { };
-
-  /**
-   *  @if maint
-   *  If we have found a result_type, extract it.
-   *  @endif
-  */
-  template<bool _Has_result_type, typename _Functor>
-    struct _Maybe_get_result_type
-    { };
-
-  template<typename _Functor>
-    struct _Maybe_get_result_type<true, _Functor>
-    {
-      typedef typename _Functor::result_type result_type;
-    };
-
-  /**
-   *  @if maint
-   *  Base class for any function object that has a weak result type, as
-   *  defined in 3.3/3 of TR1.
-   *  @endif
-  */
-  template<typename _Functor>
-    struct _Weak_result_type_impl
-    : _Maybe_get_result_type<_Has_result_type<_Functor>::value, _Functor>
-    {
-    };
-
-  /**
-   * @if maint
-   * Retrieve the result type for a function type.
-   * @endif 
-   */
-  template<typename _Res, typename... _ArgTypes> 
-    struct _Weak_result_type_impl<_Res(_ArgTypes...)>
-    {
-      typedef _Res result_type;
-    };
-
-  /**
-   * @if maint
-   * Retrieve the result type for a function reference.
-   * @endif 
-   */
-  template<typename _Res, typename... _ArgTypes> 
-    struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
-    {
-      typedef _Res result_type;
-    };
-
-  /**
-   * @if maint
-   * Retrieve the result type for a function pointer.
-   * @endif 
-   */
-  template<typename _Res, typename... _ArgTypes> 
-    struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
-    {
-      typedef _Res result_type;
-    };
-
-  /**
-   * @if maint
-   * Retrieve result type for a member function pointer.
-   * @endif maint
-   */ 
-  template<typename _Res, typename _Class, typename... _ArgTypes> 
-    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
-    {
-      typedef _Res result_type;
-    };
-
-  /**
-   * @if maint
-   * Retrieve result type for a const member function pointer.
-   * @endif maint
-   */ 
-  template<typename _Res, typename _Class, typename... _ArgTypes> 
-    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
-    {
-      typedef _Res result_type;
-    };
-
-  /**
-   * @if maint
-   * Retrieve result type for a volatile member function pointer.
-   * @endif maint
-   */ 
-  template<typename _Res, typename _Class, typename... _ArgTypes> 
-    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
-    {
-      typedef _Res result_type;
-    };
-
-  /**
-   * @if maint
-   * Retrieve result type for a const volatile member function pointer.
-   * @endif maint
-   */ 
-  template<typename _Res, typename _Class, typename... _ArgTypes> 
-    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)const volatile>
-    {
-      typedef _Res result_type;
-    };
-
-  /**
-   *  @if maint
-   *  Strip top-level cv-qualifiers from the function object and let
-   *  _Weak_result_type_impl perform the real work.
-   *  @endif
-  */
-  template<typename _Functor>
-    struct _Weak_result_type
-    : _Weak_result_type_impl<typename remove_cv<_Functor>::type>
-    {
-    };
-
-  template<typename _Signature>
-    class result_of;
-
-  /**
-   *  @if maint
-   *  Actual implementation of result_of. When _Has_result_type is
-   *  true, gets its result from _Weak_result_type. Otherwise, uses
-   *  the function object's member template result to extract the
-   *  result type.
-   *  @endif
-  */
-  template<bool _Has_result_type, typename _Signature>
-    struct _Result_of_impl;
-
-  // Handle member data pointers using _Mem_fn's logic
-  template<typename _Res, typename _Class, typename _T1>
-    struct _Result_of_impl<false, _Res _Class::*(_T1)>
-    {
-      typedef typename _Mem_fn<_Res _Class::*>
-                ::template _Result_type<_T1>::type type;
-    };
-
-  /**
-   * @if maint
-   * Determine whether we can determine a result type from @c Functor 
-   * alone.
-   * @endif
-   */ 
-  template<typename _Functor, typename... _ArgTypes>
-    class result_of<_Functor(_ArgTypes...)>
-    : public _Result_of_impl<
-               _Has_result_type<_Weak_result_type<_Functor> >::value,
-               _Functor(_ArgTypes...)>
-    {
-    };
-
-  /**
-   * @if maint
-   * We already know the result type for @c Functor; use it.
-   * @endif
-   */
-  template<typename _Functor, typename... _ArgTypes>
-    struct _Result_of_impl<true, _Functor(_ArgTypes...)>
-    {
-      typedef typename _Weak_result_type<_Functor>::result_type type;
-    };
-
-  /**
-   * @if maint
-   * We need to compute the result type for this invocation the hard 
-   * way.
-   * @endif
-   */
-  template<typename _Functor, typename... _ArgTypes>
-    struct _Result_of_impl<false, _Functor(_ArgTypes...)>
-    {
-      typedef typename _Functor
-                ::template result<_Functor(_ArgTypes...)>::type type;
-    };
-
-  /**
-   * @if maint
-   * It is unsafe to access ::result when there are zero arguments, so we 
-   * return @c void instead.
-   * @endif
-   */
-  template<typename _Functor>
-    struct _Result_of_impl<false, _Functor()>
-    {
-      typedef void type;
-    };
-
-  /**
-   *  @if maint
-   *  Determines if the type _Tp derives from unary_function.
-   *  @endif
-  */
-  template<typename _Tp>
-    struct _Derives_from_unary_function : __sfinae_types
-    {
-    private:
-      template<typename _T1, typename _Res>
-        static __one __test(const volatile unary_function<_T1, _Res>*);
-
-      // It's tempting to change "..." to const volatile void*, but
-      // that fails when _Tp is a function type.
-      static __two __test(...);
-
-    public:
-      static const bool value = sizeof(__test((_Tp*)0)) == 1;
-    };
-
-  /**
-   *  @if maint
-   *  Determines if the type _Tp derives from binary_function.
-   *  @endif
-  */
-  template<typename _Tp>
-    struct _Derives_from_binary_function : __sfinae_types
-    {
-    private:
-      template<typename _T1, typename _T2, typename _Res>
-        static __one __test(const volatile binary_function<_T1, _T2, _Res>*);
-
-      // It's tempting to change "..." to const volatile void*, but
-      // that fails when _Tp is a function type.
-      static __two __test(...);
-
-    public:
-      static const bool value = sizeof(__test((_Tp*)0)) == 1;
-    };
-
-  /**
-   *  @if maint
-   *  Turns a function type into a function pointer type
-   *  @endif
-  */
-  template<typename _Tp, bool _IsFunctionType = is_function<_Tp>::value>
-    struct _Function_to_function_pointer
-    {
-      typedef _Tp type;
-    };
-
-  template<typename _Tp>
-    struct _Function_to_function_pointer<_Tp, true>
-    {
-      typedef _Tp* type;
-    };
-
-  /**
-   * @if maint
-   * Invoke a function object, which may be either a member pointer or a
-   * function object. The first parameter will tell which.
-   * @endif
-   */
-  template<typename _Functor, typename... _Args>
-    inline
-    typename __gnu_cxx::__enable_if<
-             (!is_member_pointer<_Functor>::value
-              && !is_function<_Functor>::value
-              && !is_function<typename remove_pointer<_Functor>::type>::value),
-             typename result_of<_Functor(_Args...)>::type
-           >::__type
-    __invoke(_Functor& __f, _Args&... __args)
-    {
-      return __f(__args...);
-    }
-
-  template<typename _Functor, typename... _Args>
-    inline
-    typename __gnu_cxx::__enable_if<
-             (is_member_pointer<_Functor>::value
-              && !is_function<_Functor>::value
-              && !is_function<typename remove_pointer<_Functor>::type>::value),
-             typename result_of<_Functor(_Args...)>::type
-           >::__type
-    __invoke(_Functor& __f, _Args&... __args)
-    {
-      return mem_fn(__f)(__args...);
-    }
-
-  // To pick up function references (that will become function pointers)
-  template<typename _Functor, typename... _Args>
-    inline
-    typename __gnu_cxx::__enable_if<
-             (is_pointer<_Functor>::value
-              && is_function<typename remove_pointer<_Functor>::type>::value),
-             typename result_of<_Functor(_Args...)>::type
-           >::__type
-    __invoke(_Functor __f, _Args&... __args)
-    {
-      return __f(__args...);
-    }
-
-  /**
-   *  @if maint
-   *  Knowing which of unary_function and binary_function _Tp derives
-   *  from, derives from the same and ensures that reference_wrapper
-   *  will have a weak result type. See cases below.
-   *  @endif
-   */
-  template<bool _Unary, bool _Binary, typename _Tp>
-    struct _Reference_wrapper_base_impl;
-
-  // Not a unary_function or binary_function, so try a weak result type
-  template<typename _Tp>
-    struct _Reference_wrapper_base_impl<false, false, _Tp>
-    : _Weak_result_type<_Tp>
-    { };
-
-  // unary_function but not binary_function
-  template<typename _Tp>
-    struct _Reference_wrapper_base_impl<true, false, _Tp>
-    : unary_function<typename _Tp::argument_type,
-		     typename _Tp::result_type>
-    { };
-
-  // binary_function but not unary_function
-  template<typename _Tp>
-    struct _Reference_wrapper_base_impl<false, true, _Tp>
-    : binary_function<typename _Tp::first_argument_type,
-		      typename _Tp::second_argument_type,
-		      typename _Tp::result_type>
-    { };
-
-  // both unary_function and binary_function. import result_type to
-  // avoid conflicts.
-   template<typename _Tp>
-    struct _Reference_wrapper_base_impl<true, true, _Tp>
-    : unary_function<typename _Tp::argument_type,
-		     typename _Tp::result_type>,
-      binary_function<typename _Tp::first_argument_type,
-		      typename _Tp::second_argument_type,
-		      typename _Tp::result_type>
-    {
-      typedef typename _Tp::result_type result_type;
-    };
-
-  /**
-   *  @if maint
-   *  Derives from unary_function or binary_function when it
-   *  can. Specializations handle all of the easy cases. The primary
-   *  template determines what to do with a class type, which may
-   *  derive from both unary_function and binary_function.
-   *  @endif
-  */
-  template<typename _Tp>
-    struct _Reference_wrapper_base
-    : _Reference_wrapper_base_impl<
-      _Derives_from_unary_function<_Tp>::value,
-      _Derives_from_binary_function<_Tp>::value,
-      _Tp>
-    { };
-
-  // - a function type (unary)
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res(_T1)>
-    : unary_function<_T1, _Res>
-    { };
-
-  // - a function type (binary)
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res(_T1, _T2)>
-    : binary_function<_T1, _T2, _Res>
-    { };
-
-  // - a function pointer type (unary)
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res(*)(_T1)>
-    : unary_function<_T1, _Res>
-    { };
-
-  // - a function pointer type (binary)
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
-    : binary_function<_T1, _T2, _Res>
-    { };
-
-  // - a pointer to member function type (unary, no qualifiers)
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res (_T1::*)()>
-    : unary_function<_T1*, _Res>
-    { };
-
-  // - a pointer to member function type (binary, no qualifiers)
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
-    : binary_function<_T1*, _T2, _Res>
-    { };
-
-  // - a pointer to member function type (unary, const)
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res (_T1::*)() const>
-    : unary_function<const _T1*, _Res>
-    { };
-
-  // - a pointer to member function type (binary, const)
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
-    : binary_function<const _T1*, _T2, _Res>
-    { };
-
-  // - a pointer to member function type (unary, volatile)
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
-    : unary_function<volatile _T1*, _Res>
-    { };
-
-  // - a pointer to member function type (binary, volatile)
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
-    : binary_function<volatile _T1*, _T2, _Res>
-    { };
-
-  // - a pointer to member function type (unary, const volatile)
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
-    : unary_function<const volatile _T1*, _Res>
-    { };
-
-  // - a pointer to member function type (binary, const volatile)
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
-    : binary_function<const volatile _T1*, _T2, _Res>
-    { };
-
-  template<typename _Tp>
-    class reference_wrapper
-    : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
-    {
-      // If _Tp is a function type, we can't form result_of<_Tp(...)>,
-      // so turn it into a function pointer type.
-      typedef typename _Function_to_function_pointer<_Tp>::type
-        _M_func_type;
-
-      _Tp* _M_data;
-    public:
-      typedef _Tp type;
-
-      explicit
-      reference_wrapper(_Tp& __indata): _M_data(&__indata)
-      { }
-
-      reference_wrapper(const reference_wrapper<_Tp>& __inref):
-      _M_data(__inref._M_data)
-      { }
-
-      reference_wrapper&
-      operator=(const reference_wrapper<_Tp>& __inref)
-      {
-        _M_data = __inref._M_data;
-        return *this;
-      }
-
-      operator _Tp&() const
-      { return this->get(); }
-
-      _Tp&
-      get() const
-      { return *_M_data; }
-
-      template<typename... _Args>
-        typename result_of<_M_func_type(_Args...)>::type
-        operator()(_Args&... __args) const
-        {
-	  return __invoke(get(), __args...);
-	}
-    };
-
-
-  // Denotes a reference should be taken to a variable.
-  template<typename _Tp>
-    inline reference_wrapper<_Tp>
-    ref(_Tp& __t)
-    { return reference_wrapper<_Tp>(__t); }
-
-  // Denotes a const reference should be taken to a variable.
-  template<typename _Tp>
-    inline reference_wrapper<const _Tp>
-    cref(const _Tp& __t)
-    { return reference_wrapper<const _Tp>(__t); }
-
-  template<typename _Tp>
-    inline reference_wrapper<_Tp>
-    ref(reference_wrapper<_Tp> __t)
-    { return ref(__t.get()); }
-
-  template<typename _Tp>
-    inline reference_wrapper<const _Tp>
-    cref(reference_wrapper<_Tp> __t)
-    { return cref(__t.get()); }
-
-  template<typename _Tp, bool>
-    struct _Mem_fn_const_or_non
-    {
-      typedef const _Tp& type;
-    };
-
-  template<typename _Tp>
-    struct _Mem_fn_const_or_non<_Tp, false>
-    {
-      typedef _Tp& type;
-    };
-
-  /**
-   * @if maint
-   * Derives from @c unary_function or @c binary_function, or perhaps
-   * nothing, depending on the number of arguments provided. The
-   * primary template is the basis case, which derives nothing.
-   * @endif maint
-   */
-  template<typename _Res, typename... _ArgTypes> 
-    struct _Maybe_unary_or_binary_function { };
-
-  /**
-   * @if maint
-   * Derives from @c unary_function, as appropriate.
-   * @endif
-   */ 
-  template<typename _Res, typename _T1> 
-    struct _Maybe_unary_or_binary_function<_Res, _T1>
-    : std::unary_function<_T1, _Res> { };
-
-  /**
-   * @if maint
-   * Derives from @c binary_function, as appropriate.
-   * @endif
-   */ 
-  template<typename _Res, typename _T1, typename _T2> 
-    struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
-    : std::binary_function<_T1, _T2, _Res> { };
-
-  /**
-   * @if maint
-   * Implementation of @c mem_fn for member function pointers.
-   * @endif
-   */
-  template<typename _Res, typename _Class, typename... _ArgTypes>
-    class _Mem_fn<_Res (_Class::*)(_ArgTypes...)>
-    : public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>
-    {
-      typedef _Res (_Class::*_Functor)(_ArgTypes...);
-
-      template<typename _Tp>
-        _Res
-        _M_call(_Tp& __object, const volatile _Class *, 
-                _ArgTypes... __args) const
-        { return (__object.*__pmf)(__args...); }
-
-      template<typename _Tp>
-        _Res
-        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
-        { return ((*__ptr).*__pmf)(__args...); }
-
-    public:
-      typedef _Res result_type;
-
-      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
-
-      // Handle objects
-      _Res
-      operator()(_Class& __object, _ArgTypes... __args) const
-      { return (__object.*__pmf)(__args...); }
-
-      // Handle pointers
-      _Res
-      operator()(_Class* __object, _ArgTypes... __args) const
-      { return (__object->*__pmf)(__args...); }
-
-      // Handle smart pointers, references and pointers to derived
-      template<typename _Tp>
-        _Res
-	operator()(_Tp& __object, _ArgTypes... __args) const
-        { return _M_call(__object, &__object, __args...); }
-
-    private:
-      _Functor __pmf;
-    };
-
-  /**
-   * @if maint
-   * Implementation of @c mem_fn for const member function pointers.
-   * @endif
-   */
-  template<typename _Res, typename _Class, typename... _ArgTypes>
-    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const>
-    : public _Maybe_unary_or_binary_function<_Res, const _Class*, 
-					     _ArgTypes...>
-    {
-      typedef _Res (_Class::*_Functor)(_ArgTypes...) const;
-
-      template<typename _Tp>
-        _Res
-        _M_call(_Tp& __object, const volatile _Class *, 
-                _ArgTypes... __args) const
-        { return (__object.*__pmf)(__args...); }
-
-      template<typename _Tp>
-        _Res
-        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
-        { return ((*__ptr).*__pmf)(__args...); }
-
-    public:
-      typedef _Res result_type;
-
-      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
-
-      // Handle objects
-      _Res
-      operator()(const _Class& __object, _ArgTypes... __args) const
-      { return (__object.*__pmf)(__args...); }
-
-      // Handle pointers
-      _Res
-      operator()(const _Class* __object, _ArgTypes... __args) const
-      { return (__object->*__pmf)(__args...); }
-
-      // Handle smart pointers, references and pointers to derived
-      template<typename _Tp>
-        _Res operator()(_Tp& __object, _ArgTypes... __args) const
-        { return _M_call(__object, &__object, __args...); }
-
-    private:
-      _Functor __pmf;
-    };
-
-  /**
-   * @if maint
-   * Implementation of @c mem_fn for volatile member function pointers.
-   * @endif
-   */
-  template<typename _Res, typename _Class, typename... _ArgTypes>
-    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile>
-    : public _Maybe_unary_or_binary_function<_Res, volatile _Class*, 
-					     _ArgTypes...>
-    {
-      typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile;
-
-      template<typename _Tp>
-        _Res
-        _M_call(_Tp& __object, const volatile _Class *, 
-                _ArgTypes... __args) const
-        { return (__object.*__pmf)(__args...); }
-
-      template<typename _Tp>
-        _Res
-        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
-        { return ((*__ptr).*__pmf)(__args...); }
-
-    public:
-      typedef _Res result_type;
-
-      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
-
-      // Handle objects
-      _Res
-      operator()(volatile _Class& __object, _ArgTypes... __args) const
-      { return (__object.*__pmf)(__args...); }
-
-      // Handle pointers
-      _Res
-      operator()(volatile _Class* __object, _ArgTypes... __args) const
-      { return (__object->*__pmf)(__args...); }
-
-      // Handle smart pointers, references and pointers to derived
-      template<typename _Tp>
-        _Res
-	operator()(_Tp& __object, _ArgTypes... __args) const
-        { return _M_call(__object, &__object, __args...); }
-
-    private:
-      _Functor __pmf;
-    };
-
-  /**
-   * @if maint
-   * Implementation of @c mem_fn for const volatile member function pointers.
-   * @endif
-   */
-  template<typename _Res, typename _Class, typename... _ArgTypes>
-    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile>
-    : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*, 
-					     _ArgTypes...>
-    {
-      typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile;
-
-      template<typename _Tp>
-        _Res
-        _M_call(_Tp& __object, const volatile _Class *, 
-                _ArgTypes... __args) const
-        { return (__object.*__pmf)(__args...); }
-
-      template<typename _Tp>
-        _Res
-        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
-        { return ((*__ptr).*__pmf)(__args...); }
-
-    public:
-      typedef _Res result_type;
-
-      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
-
-      // Handle objects
-      _Res 
-      operator()(const volatile _Class& __object, _ArgTypes... __args) const
-      { return (__object.*__pmf)(__args...); }
-
-      // Handle pointers
-      _Res 
-      operator()(const volatile _Class* __object, _ArgTypes... __args) const
-      { return (__object->*__pmf)(__args...); }
-
-      // Handle smart pointers, references and pointers to derived
-      template<typename _Tp>
-        _Res operator()(_Tp& __object, _ArgTypes... __args) const
-        { return _M_call(__object, &__object, __args...); }
-
-    private:
-      _Functor __pmf;
-    };
-
-
-  template<typename _Res, typename _Class>
-    class _Mem_fn<_Res _Class::*>
-    {
-      // This bit of genius is due to Peter Dimov, improved slightly by
-      // Douglas Gregor.
-      template<typename _Tp>
-        _Res&
-        _M_call(_Tp& __object, _Class *) const
-        { return __object.*__pm; }
-
-      template<typename _Tp, typename _Up>
-        _Res&
-        _M_call(_Tp& __object, _Up * const *) const
-        { return (*__object).*__pm; }
-
-      template<typename _Tp, typename _Up>
-        const _Res&
-        _M_call(_Tp& __object, const _Up * const *) const
-        { return (*__object).*__pm; }
-
-      template<typename _Tp>
-        const _Res&
-        _M_call(_Tp& __object, const _Class *) const
-        { return __object.*__pm; }
-
-      template<typename _Tp>
-        const _Res&
-        _M_call(_Tp& __ptr, const volatile void*) const
-        { return (*__ptr).*__pm; }
-
-      template<typename _Tp> static _Tp& __get_ref();
-
-      template<typename _Tp>
-        static __sfinae_types::__one __check_const(_Tp&, _Class*);
-      template<typename _Tp, typename _Up>
-        static __sfinae_types::__one __check_const(_Tp&, _Up * const *);
-      template<typename _Tp, typename _Up>
-        static __sfinae_types::__two __check_const(_Tp&, const _Up * const *);
-      template<typename _Tp>
-        static __sfinae_types::__two __check_const(_Tp&, const _Class*);
-      template<typename _Tp>
-        static __sfinae_types::__two __check_const(_Tp&, const volatile void*);
-
-    public:
-      template<typename _Tp>
-        struct _Result_type
-	: _Mem_fn_const_or_non<_Res,
-	  (sizeof(__sfinae_types::__two)
-	   == sizeof(__check_const<_Tp>(__get_ref<_Tp>(), (_Tp*)0)))>
-        { };
-
-      template<typename _Signature>
-        struct result;
-
-      template<typename _CVMem, typename _Tp>
-        struct result<_CVMem(_Tp)>
-	: public _Result_type<_Tp> { };
-
-      template<typename _CVMem, typename _Tp>
-        struct result<_CVMem(_Tp&)>
-	: public _Result_type<_Tp> { };
-
-      explicit
-      _Mem_fn(_Res _Class::*__pm) : __pm(__pm) { }
-
-      // Handle objects
-      _Res&
-      operator()(_Class& __object) const
-      { return __object.*__pm; }
-
-      const _Res&
-      operator()(const _Class& __object) const
-      { return __object.*__pm; }
-
-      // Handle pointers
-      _Res&
-      operator()(_Class* __object) const
-      { return __object->*__pm; }
-
-      const _Res&
-      operator()(const _Class* __object) const
-      { return __object->*__pm; }
-
-      // Handle smart pointers and derived
-      template<typename _Tp>
-        typename _Result_type<_Tp>::type
-        operator()(_Tp& __unknown) const
-        { return _M_call(__unknown, &__unknown); }
-
-    private:
-      _Res _Class::*__pm;
-    };
-
-  /**
-   *  @brief Returns a function object that forwards to the member
-   *  pointer @a pm.
-   */
-  template<typename _Tp, typename _Class>
-    inline _Mem_fn<_Tp _Class::*>
-    mem_fn(_Tp _Class::* __pm)
-    {
-      return _Mem_fn<_Tp _Class::*>(__pm);
-    }
-
-  /**
-   *  @brief Determines if the given type _Tp is a function object
-   *  should be treated as a subexpression when evaluating calls to
-   *  function objects returned by bind(). [TR1 3.6.1]
-   */
-  template<typename _Tp>
-    struct is_bind_expression
-    { static const bool value = false; };
-
-  template<typename _Tp>
-    const bool is_bind_expression<_Tp>::value;
-
-  /**
-   *  @brief Determines if the given type _Tp is a placeholder in a
-   *  bind() expression and, if so, which placeholder it is. [TR1 3.6.2]
-   */
-  template<typename _Tp>
-    struct is_placeholder
-    { static const int value = 0; };
-
-  template<typename _Tp>
-    const int is_placeholder<_Tp>::value;
-
-  /**
-   *  @if maint
-   *  The type of placeholder objects defined by libstdc++.
-   *  @endif
-   */
-  template<int _Num> struct _Placeholder { };
-
-  // Define a large number of placeholders. There is no way to
-  // simplify this with variadic templates, because we're introducing
-  // unique names for each.
-  namespace placeholders { namespace {
-    _Placeholder<1> _1;
-    _Placeholder<2> _2;
-    _Placeholder<3> _3;
-    _Placeholder<4> _4;
-    _Placeholder<5> _5;
-    _Placeholder<6> _6;
-    _Placeholder<7> _7;
-    _Placeholder<8> _8;
-    _Placeholder<9> _9;
-    _Placeholder<10> _10;
-    _Placeholder<11> _11;
-    _Placeholder<12> _12;
-    _Placeholder<13> _13;
-    _Placeholder<14> _14;
-    _Placeholder<15> _15;
-    _Placeholder<16> _16;
-    _Placeholder<17> _17;
-    _Placeholder<18> _18;
-    _Placeholder<19> _19;
-    _Placeholder<20> _20;
-    _Placeholder<21> _21;
-    _Placeholder<22> _22;
-    _Placeholder<23> _23;
-    _Placeholder<24> _24;
-    _Placeholder<25> _25;
-    _Placeholder<26> _26;
-    _Placeholder<27> _27;
-    _Placeholder<28> _28;
-    _Placeholder<29> _29;
-  } }
-
-  /**
-   *  @if maint
-   *  Partial specialization of is_placeholder that provides the placeholder
-   *  number for the placeholder objects defined by libstdc++.
-   *  @endif
-   */
-  template<int _Num>
-    struct is_placeholder<_Placeholder<_Num> >
-    { static const int value = _Num; };
-
-  template<int _Num>
-    const int is_placeholder<_Placeholder<_Num> >::value;
-
-  /**
-   * @if maint
-   * Stores a tuple of indices. Used by bind() to extract the elements
-   * in a tuple. 
-   * @endif
-   */
-  template<int... _Indexes>
-    struct _Index_tuple { };
-
-  /**
-   *  @if maint
-   *  Builds an _Index_tuple<0, 1, 2, ..., _Num-1>.
-   *  @endif
-   */
-  template<std::size_t _Num, typename _Tuple = _Index_tuple<> >
-    struct _Build_index_tuple;
- 
-  template<std::size_t _Num, int... _Indexes> 
-    struct _Build_index_tuple<_Num, _Index_tuple<_Indexes...> >
-    : _Build_index_tuple<_Num - 1, 
-                         _Index_tuple<_Indexes..., sizeof...(_Indexes)> >
-    {
-    };
-
-  template<int... _Indexes>
-    struct _Build_index_tuple<0, _Index_tuple<_Indexes...> >
-    {
-      typedef _Index_tuple<_Indexes...> __type;
-    };
-
-  /** 
-   * @if maint
-   * Used by _Safe_tuple_element to indicate that there is no tuple
-   * element at this position.
-   * @endif
-   */
-  struct _No_tuple_element;
-
-  /**
-   * @if maint
-   * Implementation helper for _Safe_tuple_element. This primary
-   * template handles the case where it is safe to use @c
-   * tuple_element.
-   * @endif
-   */
-  template<int __i, typename _Tuple, bool _IsSafe>
-    struct _Safe_tuple_element_impl
-    : tuple_element<__i, _Tuple> { };
-
-  /**
-   * @if maint
-   * Implementation helper for _Safe_tuple_element. This partial
-   * specialization handles the case where it is not safe to use @c
-   * tuple_element. We just return @c _No_tuple_element.
-   * @endif
-   */
-  template<int __i, typename _Tuple>
-    struct _Safe_tuple_element_impl<__i, _Tuple, false>
-    {
-      typedef _No_tuple_element type;
-    };
-
-  /**
-   * Like tuple_element, but returns @c _No_tuple_element when
-   * tuple_element would return an error.
-   */
- template<int __i, typename _Tuple>
-   struct _Safe_tuple_element
-   : _Safe_tuple_element_impl<__i, _Tuple, 
-                              (__i >= 0 && __i < tuple_size<_Tuple>::value)>
-   {
-   };
-
-  /**
-   *  @if maint
-   *  Maps an argument to bind() into an actual argument to the bound
-   *  function object [TR1 3.6.3/5]. Only the first parameter should
-   *  be specified: the rest are used to determine among the various
-   *  implementations. Note that, although this class is a function
-   *  object, isn't not entirely normal because it takes only two
-   *  parameters regardless of the number of parameters passed to the
-   *  bind expression. The first parameter is the bound argument and
-   *  the second parameter is a tuple containing references to the
-   *  rest of the arguments.
-   *  @endif
-   */
-  template<typename _Arg,
-           bool _IsBindExp = is_bind_expression<_Arg>::value,
-           bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
-    class _Mu;
-
-  /**
-   *  @if maint
-   *  If the argument is reference_wrapper<_Tp>, returns the
-   *  underlying reference. [TR1 3.6.3/5 bullet 1]
-   *  @endif
-   */
-  template<typename _Tp>
-    class _Mu<reference_wrapper<_Tp>, false, false>
-    {
-    public:
-      typedef _Tp& result_type;
-
-      /* Note: This won't actually work for const volatile
-       * reference_wrappers, because reference_wrapper::get() is const
-       * but not volatile-qualified. This might be a defect in the TR.
-       */
-      template<typename _CVRef, typename _Tuple>
-        result_type
-        operator()(_CVRef& __arg, const _Tuple&) const volatile
-        { return __arg.get(); }
-    };
-
-  /**
-   *  @if maint
-   *  If the argument is a bind expression, we invoke the underlying
-   *  function object with the same cv-qualifiers as we are given and
-   *  pass along all of our arguments (unwrapped). [TR1 3.6.3/5 bullet 2]
-   *  @endif
-   */
-  template<typename _Arg>
-    class _Mu<_Arg, true, false>
-    {
-    public:
-      template<typename _Signature> class result;
-
-      // Determine the result type when we pass the arguments along. This
-      // involves passing along the cv-qualifiers placed on _Mu and
-      // unwrapping the argument bundle.
-      template<typename _CVMu, typename _CVArg, typename... _Args>
-        class result<_CVMu(_CVArg, tuple<_Args...>)>
-	: public result_of<_CVArg(_Args...)> { };
-
-      template<typename _CVArg, typename... _Args>
-        typename result_of<_CVArg(_Args...)>::type
-        operator()(_CVArg& __arg,
-		   const tuple<_Args...>& __tuple) const volatile
-        {
-	  // Construct an index tuple and forward to __call
-	  typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
-	    _Indexes;
-	  return this->__call(__arg, __tuple, _Indexes());
-	}
-
-    private:
-      // Invokes the underlying function object __arg by unpacking all
-      // of the arguments in the tuple. 
-      template<typename _CVArg, typename... _Args, int... _Indexes>
-        typename result_of<_CVArg(_Args...)>::type
-        __call(_CVArg& __arg, const tuple<_Args...>& __tuple,
-	       const _Index_tuple<_Indexes...>&) const volatile
-        {
-	  return __arg(_GLIBCXX_TR1::get<_Indexes>(__tuple)...);
-	}
-    };
-
-  /**
-   *  @if maint
-   *  If the argument is a placeholder for the Nth argument, returns
-   *  a reference to the Nth argument to the bind function object.
-   *  [TR1 3.6.3/5 bullet 3]
-   *  @endif
-   */
-  template<typename _Arg>
-    class _Mu<_Arg, false, true>
-    {
-    public:
-      template<typename _Signature> class result;
-
-      template<typename _CVMu, typename _CVArg, typename _Tuple>
-        class result<_CVMu(_CVArg, _Tuple)>
-        {
-	  // Add a reference, if it hasn't already been done for us.
-	  // This allows us to be a little bit sloppy in constructing
-	  // the tuple that we pass to result_of<...>.
-	  typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value
-						- 1), _Tuple>::type
-	    __base_type;
-
-	public:
-	  typedef typename add_reference<__base_type>::type type;
-	};
-
-      template<typename _Tuple>
-        typename result<_Mu(_Arg, _Tuple)>::type
-        operator()(const volatile _Arg&, const _Tuple& __tuple) const volatile
-        {
-	  return ::std::_GLIBCXX_TR1::get<(is_placeholder<_Arg>::value
-					   - 1)>(__tuple);
-	}
-    };
-
-  /**
-   *  @if maint
-   *  If the argument is just a value, returns a reference to that
-   *  value. The cv-qualifiers on the reference are the same as the
-   *  cv-qualifiers on the _Mu object. [TR1 3.6.3/5 bullet 4]
-   *  @endif
-   */
-  template<typename _Arg>
-    class _Mu<_Arg, false, false>
-    {
-    public:
-      template<typename _Signature> struct result;
-
-      template<typename _CVMu, typename _CVArg, typename _Tuple>
-        struct result<_CVMu(_CVArg, _Tuple)>
-        {
-	  typedef typename add_reference<_CVArg>::type type;
-	};
-
-      // Pick up the cv-qualifiers of the argument
-      template<typename _CVArg, typename _Tuple>
-        _CVArg&
-        operator()(_CVArg& __arg, const _Tuple&) const volatile
-        { return __arg; }
-    };
-
-  /**
-   *  @if maint
-   *  Maps member pointers into instances of _Mem_fn but leaves all
-   *  other function objects untouched. Used by tr1::bind(). The
-   *  primary template handles the non--member-pointer case.
-   *  @endif
-   */
-  template<typename _Tp>
-    struct _Maybe_wrap_member_pointer
-    {
-      typedef _Tp type;
-      
-      static const _Tp&
-      __do_wrap(const _Tp& __x)
-      { return __x; }
-    };
-
-  /**
-   *  @if maint
-   *  Maps member pointers into instances of _Mem_fn but leaves all
-   *  other function objects untouched. Used by tr1::bind(). This
-   *  partial specialization handles the member pointer case.
-   *  @endif
-   */
-  template<typename _Tp, typename _Class>
-    struct _Maybe_wrap_member_pointer<_Tp _Class::*>
-    {
-      typedef _Mem_fn<_Tp _Class::*> type;
-      
-      static type
-      __do_wrap(_Tp _Class::* __pm)
-      { return type(__pm); }
-    };
-
-  /**
-   *  @if maint
-   *  Type of the function object returned from bind().
-   *  @endif
-   */
-  template<typename _Signature>
-    struct _Bind;
-
-   template<typename _Functor, typename... _Bound_args>
-    class _Bind<_Functor(_Bound_args...)>
-    : public _Weak_result_type<_Functor>
-    {
-      typedef _Bind __self_type;
-      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type 
-        _Bound_indexes;
-
-      _Functor _M_f;
-      tuple<_Bound_args...> _M_bound_args;
-
-      // Call unqualified
-      template<typename... _Args, int... _Indexes>
-        typename result_of<
-                   _Functor(typename result_of<_Mu<_Bound_args> 
-                            (_Bound_args, tuple<_Args...>)>::type...)
-                 >::type
-        __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>)
-        {
-          return _M_f(_Mu<_Bound_args>()
-                      (_GLIBCXX_TR1::get<_Indexes>(_M_bound_args), __args)...);
-        }
-
-      // Call as const
-      template<typename... _Args, int... _Indexes>
-        typename result_of<
-                   const _Functor(typename result_of<_Mu<_Bound_args> 
-                                    (const _Bound_args, tuple<_Args...>)
-                                  >::type...)>::type
-        __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const
-        {
-          return _M_f(_Mu<_Bound_args>()
-                      (_GLIBCXX_TR1::get<_Indexes>(_M_bound_args), __args)...);
-        }
-
-      // Call as volatile
-      template<typename... _Args, int... _Indexes>
-        typename result_of<
-                   volatile _Functor(typename result_of<_Mu<_Bound_args> 
-                                    (volatile _Bound_args, tuple<_Args...>)
-                                  >::type...)>::type
-        __call(const tuple<_Args...>& __args, 
-               _Index_tuple<_Indexes...>) volatile
-        {
-          return _M_f(_Mu<_Bound_args>()
-                      (_GLIBCXX_TR1::get<_Indexes>(_M_bound_args), __args)...);
-        }
-
-      // Call as const volatile
-      template<typename... _Args, int... _Indexes>
-        typename result_of<
-                   const volatile _Functor(typename result_of<_Mu<_Bound_args> 
-                                    (const volatile _Bound_args, 
-                                     tuple<_Args...>)
-                                  >::type...)>::type
-        __call(const tuple<_Args...>& __args, 
-               _Index_tuple<_Indexes...>) const volatile
-        {
-          return _M_f(_Mu<_Bound_args>()
-                      (_GLIBCXX_TR1::get<_Indexes>(_M_bound_args), __args)...);
-        }
-
-     public:
-      explicit _Bind(_Functor __f, _Bound_args... __bound_args)
-        : _M_f(__f), _M_bound_args(__bound_args...) { }
-
-      // Call unqualified
-      template<typename... _Args>
-        typename result_of<
-                   _Functor(typename result_of<_Mu<_Bound_args> 
-                            (_Bound_args, tuple<_Args...>)>::type...)
-                 >::type
-        operator()(_Args&... __args)
-        {
-          return this->__call(_GLIBCXX_TR1::tie(__args...), _Bound_indexes());
-        }
-
-      // Call as const
-      template<typename... _Args>
-        typename result_of<
-                   const _Functor(typename result_of<_Mu<_Bound_args> 
-                            (const _Bound_args, tuple<_Args...>)>::type...)
-                 >::type
-        operator()(_Args&... __args) const
-        {
-          return this->__call(_GLIBCXX_TR1::tie(__args...), _Bound_indexes());
-        }
-
-
-      // Call as volatile
-      template<typename... _Args>
-        typename result_of<
-                   volatile _Functor(typename result_of<_Mu<_Bound_args> 
-                            (volatile _Bound_args, tuple<_Args...>)>::type...)
-                 >::type
-        operator()(_Args&... __args) volatile
-        {
-          return this->__call(_GLIBCXX_TR1::tie(__args...), _Bound_indexes());
-        }
-
-
-      // Call as const volatile
-      template<typename... _Args>
-        typename result_of<
-                   const volatile _Functor(typename result_of<_Mu<_Bound_args> 
-                            (const volatile _Bound_args, 
-                             tuple<_Args...>)>::type...)
-                 >::type
-        operator()(_Args&... __args) const volatile
-        {
-          return this->__call(_GLIBCXX_TR1::tie(__args...), _Bound_indexes());
-        }
-    };
-
-  /**
-   *  @if maint
-   *  Type of the function object returned from bind<R>().
-   *  @endif
-   */
-  template<typename _Result, typename _Signature>
-    struct _Bind_result;
-
-  template<typename _Result, typename _Functor, typename... _Bound_args>
-    class _Bind_result<_Result, _Functor(_Bound_args...)>
-    {
-      typedef _Bind_result __self_type;
-      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type 
-        _Bound_indexes;
-
-      _Functor _M_f;
-      tuple<_Bound_args...> _M_bound_args;
-
-      // Call unqualified
-      template<typename... _Args, int... _Indexes>
-        _Result
-        __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>)
-        {
-          return _M_f(_Mu<_Bound_args>()
-                      (_GLIBCXX_TR1::get<_Indexes>(_M_bound_args), __args)...);
-        }
-
-      // Call as const
-      template<typename... _Args, int... _Indexes>
-        _Result
-        __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const
-        {
-          return _M_f(_Mu<_Bound_args>()
-                      (_GLIBCXX_TR1::get<_Indexes>(_M_bound_args), __args)...);
-        }
-
-      // Call as volatile
-      template<typename... _Args, int... _Indexes>
-        _Result
-        __call(const tuple<_Args...>& __args, 
-               _Index_tuple<_Indexes...>) volatile
-        {
-          return _M_f(_Mu<_Bound_args>()
-                      (_GLIBCXX_TR1::get<_Indexes>(_M_bound_args), __args)...);
-        }
-
-      // Call as const volatile
-      template<typename... _Args, int... _Indexes>
-        _Result
-        __call(const tuple<_Args...>& __args, 
-               _Index_tuple<_Indexes...>) const volatile
-        {
-          return _M_f(_Mu<_Bound_args>()
-                      (_GLIBCXX_TR1::get<_Indexes>(_M_bound_args), __args)...);
-        }
-
-    public:
-      typedef _Result result_type;
-
-      explicit
-      _Bind_result(_Functor __f, _Bound_args... __bound_args)
-      : _M_f(__f), _M_bound_args(__bound_args...) { }
-
-      // Call unqualified
-      template<typename... _Args>
-        result_type
-        operator()(_Args&... __args)
-        {
-          return this->__call(_GLIBCXX_TR1::tie(__args...), _Bound_indexes());
-        }
-
-      // Call as const
-      template<typename... _Args>
-        result_type
-        operator()(_Args&... __args) const
-        {
-          return this->__call(_GLIBCXX_TR1::tie(__args...), _Bound_indexes());
-        }
-
-      // Call as volatile
-      template<typename... _Args>
-        result_type
-        operator()(_Args&... __args) volatile
-        {
-          return this->__call(_GLIBCXX_TR1::tie(__args...), _Bound_indexes());
-        }
-
-      // Call as const volatile
-      template<typename... _Args>
-        result_type
-        operator()(_Args&... __args) const volatile
-        {
-          return this->__call(_GLIBCXX_TR1::tie(__args...), _Bound_indexes());
-        }
-    };
-
-  /**
-   *  @if maint
-   *  Class template _Bind is always a bind expression.
-   *  @endif
-   */
-  template<typename _Signature>
-    struct is_bind_expression<_Bind<_Signature> >
-    { static const bool value = true; };
-
-  template<typename _Signature>
-    const bool is_bind_expression<_Bind<_Signature> >::value;
-
-  /**
-   *  @if maint
-   *  Class template _Bind_result is always a bind expression.
-   *  @endif
-   */
-  template<typename _Result, typename _Signature>
-    struct is_bind_expression<_Bind_result<_Result, _Signature> >
-    { static const bool value = true; };
-
-  template<typename _Result, typename _Signature>
-    const bool is_bind_expression<_Bind_result<_Result, _Signature> >::value;
-
-  template<typename _Functor, typename... _ArgTypes>
-    inline
-    _Bind<typename _Maybe_wrap_member_pointer<_Functor>::type(_ArgTypes...)>
-    bind(_Functor __f, _ArgTypes... __args)
-    {
-      typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type;
-      typedef typename __maybe_type::type __functor_type;
-      typedef _Bind<__functor_type(_ArgTypes...)> __result_type;
-      return __result_type(__maybe_type::__do_wrap(__f), __args...);
-    } 
-
-  template<typename _Result, typename _Functor, typename... _ArgTypes>
-    inline
-    _Bind_result<_Result,
-		 typename _Maybe_wrap_member_pointer<_Functor>::type
-                            (_ArgTypes...)>
-    bind(_Functor __f, _ArgTypes... __args)
-    {
-      typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type;
-      typedef typename __maybe_type::type __functor_type;
-      typedef _Bind_result<_Result, __functor_type(_ArgTypes...)>
-	__result_type;
-      return __result_type(__maybe_type::__do_wrap(__f), __args...);
-    }
-
-  /**
-   *  @brief Exception class thrown when class template function's
-   *  operator() is called with an empty target.
-   *
-   */
-  class bad_function_call : public std::exception { };
-
-  /**
-   *  @if maint
-   *  The integral constant expression 0 can be converted into a
-   *  pointer to this type. It is used by the function template to
-   *  accept NULL pointers.
-   *  @endif
-   */
-  struct _M_clear_type;
-
-  /**
-   *  @if maint
-   *  Trait identifying "location-invariant" types, meaning that the
-   *  address of the object (or any of its members) will not escape.
-   *  Also implies a trivial copy constructor and assignment operator.
-   *   @endif
-   */
-  template<typename _Tp>
-    struct __is_location_invariant
-    : integral_constant<bool,
-                        (is_pointer<_Tp>::value
-                         || is_member_pointer<_Tp>::value)>
-    {
-    };
-
-  class _Undefined_class;
-
-  union _Nocopy_types
-  {
-    void*       _M_object;
-    const void* _M_const_object;
-    void (*_M_function_pointer)();
-    void (_Undefined_class::*_M_member_pointer)();
-  };
-
-  union _Any_data
-  {
-    void*       _M_access()       { return &_M_pod_data[0]; }
-    const void* _M_access() const { return &_M_pod_data[0]; }
-
-    template<typename _Tp>
-      _Tp&
-      _M_access()
-      { return *static_cast<_Tp*>(_M_access()); }
-
-    template<typename _Tp>
-      const _Tp&
-      _M_access() const
-      { return *static_cast<const _Tp*>(_M_access()); }
-
-    _Nocopy_types _M_unused;
-    char _M_pod_data[sizeof(_Nocopy_types)];
-  };
-
-  enum _Manager_operation
-  {
-    __get_type_info,
-    __get_functor_ptr,
-    __clone_functor,
-    __destroy_functor
-  };
-
-  /* Simple type wrapper that helps avoid annoying const problems
-     when casting between void pointers and pointers-to-pointers. */
-  template<typename _Tp>
-    struct _Simple_type_wrapper
-    {
-      _Simple_type_wrapper(_Tp __value) : __value(__value) { }
-
-      _Tp __value;
-    };
-
-  template<typename _Tp>
-    struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
-    : __is_location_invariant<_Tp>
-    {
-    };
-
-  // Converts a reference to a function object into a callable
-  // function object.
-  template<typename _Functor>
-    inline _Functor&
-    __callable_functor(_Functor& __f)
-    { return __f; }
-
-  template<typename _Member, typename _Class>
-    inline _Mem_fn<_Member _Class::*>
-    __callable_functor(_Member _Class::* &__p)
-    { return mem_fn(__p); }
-
-  template<typename _Member, typename _Class>
-    inline _Mem_fn<_Member _Class::*>
-    __callable_functor(_Member _Class::* const &__p)
-    { return mem_fn(__p); }
-
-  template<typename _Signature>
-    class function;
-
-  /**
-   *  @if maint
-   *  Base class of all polymorphic function object wrappers.
-   *  @endif
-   */
-  class _Function_base
-  {
-  public:
-    static const std::size_t _M_max_size = sizeof(_Nocopy_types);
-    static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
-
-    template<typename _Functor>
-      class _Base_manager
-      {
-      protected:
-	static const bool __stored_locally =
-        (__is_location_invariant<_Functor>::value
-         && sizeof(_Functor) <= _M_max_size
-         && __alignof__(_Functor) <= _M_max_align
-         && (_M_max_align % __alignof__(_Functor) == 0));
-	
-	typedef integral_constant<bool, __stored_locally> _Local_storage;
-
-	// Retrieve a pointer to the function object
-	static _Functor*
-	_M_get_pointer(const _Any_data& __source)
-	{
-	  const _Functor* __ptr =
-	    __stored_locally? &__source._M_access<_Functor>()
-	    /* have stored a pointer */ : __source._M_access<_Functor*>();
-	  return const_cast<_Functor*>(__ptr);
-	}
-
-	// Clone a location-invariant function object that fits within
-	// an _Any_data structure.
-	static void
-	_M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
-	{
-	  new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
-	}
-
-	// Clone a function object that is not location-invariant or
-	// that cannot fit into an _Any_data structure.
-	static void
-	_M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
-	{
-	  __dest._M_access<_Functor*>() =
-	    new _Functor(*__source._M_access<_Functor*>());
-	}
-
-	// Destroying a location-invariant object may still require
-	// destruction.
-	static void
-	_M_destroy(_Any_data& __victim, true_type)
-	{
-	  __victim._M_access<_Functor>().~_Functor();
-	}
-	
-	// Destroying an object located on the heap.
-	static void
-	_M_destroy(_Any_data& __victim, false_type)
-	{
-	  delete __victim._M_access<_Functor*>();
-	}
-	
-      public:
-	static bool
-	_M_manager(_Any_data& __dest, const _Any_data& __source,
-		   _Manager_operation __op)
-	{
-	  switch (__op)
-	    {
-	    case __get_type_info:
-	      __dest._M_access<const type_info*>() = &typeid(_Functor);
-	      break;
-
-	    case __get_functor_ptr:
-	      __dest._M_access<_Functor*>() = _M_get_pointer(__source);
-	      break;
-	      
-	    case __clone_functor:
-	      _M_clone(__dest, __source, _Local_storage());
-	      break;
-
-	    case __destroy_functor:
-	      _M_destroy(__dest, _Local_storage());
-	      break;
-	    }
-	  return false;
-	}
-
-	static void
-	_M_init_functor(_Any_data& __functor, const _Functor& __f)
-	{
-	  _M_init_functor(__functor, __f, _Local_storage());
-	}
-	
-	template<typename _Signature>
-	  static bool
-	  _M_not_empty_function(const function<_Signature>& __f)
-	  {
-	    return __f;
-	  }
-
-	template<typename _Tp>
-	  static bool
-	  _M_not_empty_function(const _Tp*& __fp)
-	  {
-	    return __fp;
-	  }
-
-	template<typename _Class, typename _Tp>
-	  static bool
-	  _M_not_empty_function(_Tp _Class::* const& __mp)
-	  {
-	    return __mp;
-	  }
-
-	template<typename _Tp>
-	  static bool
-	  _M_not_empty_function(const _Tp&)
-	  {
-	    return true;
-	  }
-
-      private:
-	static void
-	_M_init_functor(_Any_data& __functor, const _Functor& __f, true_type)
-	{
-	  new (__functor._M_access()) _Functor(__f);
-	}
-
-	static void
-	_M_init_functor(_Any_data& __functor, const _Functor& __f, false_type)
-	{
-	  __functor._M_access<_Functor*>() = new _Functor(__f);
-	}
-      };
-
-    template<typename _Functor>
-      class _Ref_manager : public _Base_manager<_Functor*>
-      {
-	typedef _Function_base::_Base_manager<_Functor*> _Base;
-
-    public:
-	static bool
-	_M_manager(_Any_data& __dest, const _Any_data& __source,
-		   _Manager_operation __op)
-	{
-	  switch (__op)
-	    {
-	    case __get_type_info:
-	      __dest._M_access<const type_info*>() = &typeid(_Functor);
-	      break;
-	      
-	    case __get_functor_ptr:
-	      __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
-	      return is_const<_Functor>::value;
-	      break;
-	      
-	    default:
-	      _Base::_M_manager(__dest, __source, __op);
-	    }
-	  return false;
-	}
-
-	static void
-	_M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
-	{
-	  // TBD: Use address_of function instead
-	  _Base::_M_init_functor(__functor, &__f.get());
-	}
-      };
-
-    _Function_base() : _M_manager(0) { }
-    
-    ~_Function_base()
-    {
-      if (_M_manager)
-	_M_manager(_M_functor, _M_functor, __destroy_functor);
-    }
-
-
-    bool _M_empty() const { return !_M_manager; }
-
-    typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
-                                  _Manager_operation);
-
-    _Any_data     _M_functor;
-    _Manager_type _M_manager;
-  };
-
-  template<typename _Signature, typename _Functor>
-    class _Function_handler;
-
-  template<typename _Res, typename _Functor, typename... _ArgTypes>
-    class _Function_handler<_Res(_ArgTypes...), _Functor>
-    : public _Function_base::_Base_manager<_Functor>
-    {
-      typedef _Function_base::_Base_manager<_Functor> _Base;
-
-    public:
-      static _Res
-      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
-      {
-        return (*_Base::_M_get_pointer(__functor))(__args...);
-      }
-    };
-
-  template<typename _Functor, typename... _ArgTypes>
-    class _Function_handler<void(_ArgTypes...), _Functor>
-    : public _Function_base::_Base_manager<_Functor>
-    {
-      typedef _Function_base::_Base_manager<_Functor> _Base;
-
-     public:
-      static void
-      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
-      {
-        (*_Base::_M_get_pointer(__functor))(__args...);
-      }
-    };
-
-  template<typename _Res, typename _Functor, typename... _ArgTypes>
-    class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
-    : public _Function_base::_Ref_manager<_Functor>
-    {
-      typedef _Function_base::_Ref_manager<_Functor> _Base;
-
-     public:
-      static _Res
-      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
-      {
-        return 
-          __callable_functor(**_Base::_M_get_pointer(__functor))(__args...);
-      }
-    };
-
-  template<typename _Functor, typename... _ArgTypes>
-    class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
-    : public _Function_base::_Ref_manager<_Functor>
-    {
-      typedef _Function_base::_Ref_manager<_Functor> _Base;
-
-     public:
-      static void
-      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
-      {
-        __callable_functor(**_Base::_M_get_pointer(__functor))(__args...);
-      }
-    };
-
-  template<typename _Class, typename _Member, typename _Res, 
-           typename... _ArgTypes>
-    class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
-    : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
-    {
-      typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
-        _Base;
-
-     public:
-      static _Res
-      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
-      {
-        return _GLIBCXX_TR1::
-	  mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...);
-      }
-    };
-
-  template<typename _Class, typename _Member, typename... _ArgTypes>
-    class _Function_handler<void(_ArgTypes...), _Member _Class::*>
-    : public _Function_base::_Base_manager<
-                 _Simple_type_wrapper< _Member _Class::* > >
-    {
-      typedef _Member _Class::* _Functor;
-      typedef _Simple_type_wrapper<_Functor> _Wrapper;
-      typedef _Function_base::_Base_manager<_Wrapper> _Base;
-
-     public:
-      static bool
-      _M_manager(_Any_data& __dest, const _Any_data& __source,
-                 _Manager_operation __op)
-      {
-        switch (__op)
-	  {
-	  case __get_type_info:
-	    __dest._M_access<const type_info*>() = &typeid(_Functor);
-	    break;
-	    
-	  case __get_functor_ptr:
-	    __dest._M_access<_Functor*>() =
-	      &_Base::_M_get_pointer(__source)->__value;
-	    break;
-	    
-	  default:
-	    _Base::_M_manager(__dest, __source, __op);
-	  }
-        return false;
-      }
-
-      static void
-      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
-      {
-        _GLIBCXX_TR1::
-	  mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...);
-      }
-    };
-
-  template<typename _Res, typename... _ArgTypes>
-    class function<_Res(_ArgTypes...)>
-    : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
-      private _Function_base
-    {
-      /**
-       *  @if maint
-       *  This class is used to implement the safe_bool idiom.
-       *  @endif
-       */
-      struct _Hidden_type
-      {
-	_Hidden_type* _M_bool;
-      };
-
-      /**
-       *  @if maint
-       *  This typedef is used to implement the safe_bool idiom.
-       *  @endif
-       */
-      typedef _Hidden_type* _Hidden_type::* _Safe_bool;
-
-      typedef _Res _Signature_type(_ArgTypes...);
-      
-      struct _Useless {};
-      
-    public:
-      typedef _Res result_type;
-      
-      // [3.7.2.1] construct/copy/destroy
-      
-      /**
-       *  @brief Default construct creates an empty function call wrapper.
-       *  @post @c !(bool)*this
-       */
-      function() : _Function_base() { }
-      
-      /**
-       *  @brief Default construct creates an empty function call wrapper.
-       *  @post @c !(bool)*this
-       */
-      function(_M_clear_type*) : _Function_base() { }
-      
-      /**
-       *  @brief %Function copy constructor.
-       *  @param x A %function object with identical call signature.
-       *  @pre @c (bool)*this == (bool)x
-       *
-       *  The newly-created %function contains a copy of the target of @a
-       *  x (if it has one).
-       */
-      function(const function& __x);
-      
-      /**
-       *  @brief Builds a %function that targets a copy of the incoming
-       *  function object.
-       *  @param f A %function object that is callable with parameters of
-       *  type @c T1, @c T2, ..., @c TN and returns a value convertible
-       *  to @c Res.
-       *
-       *  The newly-created %function object will target a copy of @a
-       *  f. If @a f is @c reference_wrapper<F>, then this function
-       *  object will contain a reference to the function object @c
-       *  f.get(). If @a f is a NULL function pointer or NULL
-       *  pointer-to-member, the newly-created object will be empty.
-       *
-       *  If @a f is a non-NULL function pointer or an object of type @c
-       *  reference_wrapper<F>, this function will not throw.
-       */
-      template<typename _Functor>
-        function(_Functor __f,
-                 typename __gnu_cxx::__enable_if<
-                           !is_integral<_Functor>::value, _Useless>::__type
-                   = _Useless());
-
-      /**
-       *  @brief %Function assignment operator.
-       *  @param x A %function with identical call signature.
-       *  @post @c (bool)*this == (bool)x
-       *  @returns @c *this
-       *
-       *  The target of @a x is copied to @c *this. If @a x has no
-       *  target, then @c *this will be empty.
-       *
-       *  If @a x targets a function pointer or a reference to a function
-       *  object, then this operation will not throw an exception.
-       */
-      function&
-      operator=(const function& __x)
-      {
-        function(__x).swap(*this);
-        return *this;
-      }
-
-      /**
-       *  @brief %Function assignment to zero.
-       *  @post @c !(bool)*this
-       *  @returns @c *this
-       *
-       *  The target of @a *this is deallocated, leaving it empty.
-       */
-      function&
-      operator=(_M_clear_type*)
-      {
-        if (_M_manager)
-	  {
-	    _M_manager(_M_functor, _M_functor, __destroy_functor);
-	    _M_manager = 0;
-	    _M_invoker = 0;
-	  }
-        return *this;
-      }
-
-      /**
-       *  @brief %Function assignment to a new target.
-       *  @param f A %function object that is callable with parameters of
-       *  type @c T1, @c T2, ..., @c TN and returns a value convertible
-       *  to @c Res.
-       *  @return @c *this
-       *
-       *  This  %function object wrapper will target a copy of @a
-       *  f. If @a f is @c reference_wrapper<F>, then this function
-       *  object will contain a reference to the function object @c
-       *  f.get(). If @a f is a NULL function pointer or NULL
-       *  pointer-to-member, @c this object will be empty.
-       *
-       *  If @a f is a non-NULL function pointer or an object of type @c
-       *  reference_wrapper<F>, this function will not throw.
-       */
-      template<typename _Functor>
-        typename __gnu_cxx::__enable_if<!is_integral<_Functor>::value,
-	                                function&>::__type
-	operator=(_Functor __f)
-	{
-	  function(__f).swap(*this);
-	  return *this;
-	}
-
-      // [3.7.2.2] function modifiers
-      
-      /**
-       *  @brief Swap the targets of two %function objects.
-       *  @param f A %function with identical call signature.
-       *
-       *  Swap the targets of @c this function object and @a f. This
-       *  function will not throw an exception.
-       */
-      void swap(function& __x)
-      {
-	_Any_data __old_functor = _M_functor;
-	_M_functor = __x._M_functor;
-	__x._M_functor = __old_functor;
-	_Manager_type __old_manager = _M_manager;
-	_M_manager = __x._M_manager;
-	__x._M_manager = __old_manager;
-	_Invoker_type __old_invoker = _M_invoker;
-	_M_invoker = __x._M_invoker;
-	__x._M_invoker = __old_invoker;
-      }
-      
-      // [3.7.2.3] function capacity
-
-      /**
-       *  @brief Determine if the %function wrapper has a target.
-       *
-       *  @return @c true when this %function object contains a target,
-       *  or @c false when it is empty.
-       *
-       *  This function will not throw an exception.
-       */
-      operator _Safe_bool() const
-      {
-        if (_M_empty())
-	  return 0;
-	else
-	  return &_Hidden_type::_M_bool;
-      }
-
-      // [3.7.2.4] function invocation
-
-      /**
-       *  @brief Invokes the function targeted by @c *this.
-       *  @returns the result of the target.
-       *  @throws bad_function_call when @c !(bool)*this
-       *
-       *  The function call operator invokes the target function object
-       *  stored by @c this.
-       */
-      _Res operator()(_ArgTypes... __args) const;
-      
-      // [3.7.2.5] function target access
-      /**
-       *  @brief Determine the type of the target of this function object
-       *  wrapper.
-       *
-       *  @returns the type identifier of the target function object, or
-       *  @c typeid(void) if @c !(bool)*this.
-       *
-       *  This function will not throw an exception.
-       */
-      const type_info& target_type() const;
-      
-      /**
-       *  @brief Access the stored target function object.
-       *
-       *  @return Returns a pointer to the stored target function object,
-       *  if @c typeid(Functor).equals(target_type()); otherwise, a NULL
-       *  pointer.
-       *
-       * This function will not throw an exception.
-       */
-      template<typename _Functor>       _Functor* target();
-      
-      /**
-       *  @overload
-       */
-      template<typename _Functor> const _Functor* target() const;
-      
-    private:
-      // [3.7.2.6] undefined operators
-      template<typename _Function>
-	void operator==(const function<_Function>&) const;
-      template<typename _Function>
-	void operator!=(const function<_Function>&) const;
-
-      typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...);
-      _Invoker_type _M_invoker;
-  };
-
-  template<typename _Res, typename... _ArgTypes>
-    function<_Res(_ArgTypes...)>::
-    function(const function& __x)
-    : _Function_base()
-    {
-      if (__x)
-	{
-	  _M_invoker = __x._M_invoker;
-	  _M_manager = __x._M_manager;
-	  __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
-	}
-    }
-
-  template<typename _Res, typename... _ArgTypes>
-    template<typename _Functor>
-      function<_Res(_ArgTypes...)>::
-      function(_Functor __f,
-	       typename __gnu_cxx::__enable_if<
-                       !is_integral<_Functor>::value, _Useless>::__type)
-      : _Function_base()
-      {
-	typedef _Function_handler<_Signature_type, _Functor> _My_handler;
-
-	if (_My_handler::_M_not_empty_function(__f))
-	  {
-	    _M_invoker = &_My_handler::_M_invoke;
-	    _M_manager = &_My_handler::_M_manager;
-	    _My_handler::_M_init_functor(_M_functor, __f);
-	  }
-      }
+#include <tr1/functional_hash.h>
 
-  template<typename _Res, typename... _ArgTypes>
-    _Res
-    function<_Res(_ArgTypes...)>::
-    operator()(_ArgTypes... __args) const
-    {
-      if (_M_empty())
-        {
-#if __EXCEPTIONS
-          throw bad_function_call();
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/functional>
 #else
-          __builtin_abort();
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/functional>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
 #endif
-        }
-      return _M_invoker(_M_functor, __args...);
-    }
-
-  template<typename _Res, typename... _ArgTypes>
-    const type_info&
-    function<_Res(_ArgTypes...)>::
-    target_type() const
-    {
-      if (_M_manager)
-        {
-          _Any_data __typeinfo_result;
-          _M_manager(__typeinfo_result, _M_functor, __get_type_info);
-          return *__typeinfo_result._M_access<const type_info*>();
-        }
-      else
-	return typeid(void);
-    }
-
-  template<typename _Res, typename... _ArgTypes>
-    template<typename _Functor>
-      _Functor*
-      function<_Res(_ArgTypes...)>::
-      target()
-      {
-	if (typeid(_Functor) == target_type() && _M_manager)
-	  {
-	    _Any_data __ptr;
-	    if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
-		&& !is_const<_Functor>::value)
-	      return 0;
-	    else
-	      return __ptr._M_access<_Functor*>();
-	  }
-	else
-	  return 0;
-      }
-
-  template<typename _Res, typename... _ArgTypes>
-    template<typename _Functor>
-      const _Functor*
-      function<_Res(_ArgTypes...)>::
-      target() const
-      {
-	if (typeid(_Functor) == target_type() && _M_manager)
-	  {
-	    _Any_data __ptr;
-	    _M_manager(__ptr, _M_functor, __get_functor_ptr);
-	    return __ptr._M_access<const _Functor*>();
-	  }
-	else
-	  return 0;
-      }
-
-  // [3.7.2.7] null pointer comparisons
-
-  /**
-   *  @brief Compares a polymorphic function object wrapper against 0
-   *  (the NULL pointer).
-   *  @returns @c true if the wrapper has no target, @c false otherwise
-   *
-   *  This function will not throw an exception.
-   */
-  template<typename _Signature>
-    inline bool
-    operator==(const function<_Signature>& __f, _M_clear_type*)
-    { 
-      return !__f;
-    }
-
-  /**
-   *  @overload
-   */
-  template<typename _Signature>
-    inline bool
-    operator==(_M_clear_type*, const function<_Signature>& __f)
-    {
-      return !__f;
-    }
 
-  /**
-   *  @brief Compares a polymorphic function object wrapper against 0
-   *  (the NULL pointer).
-   *  @returns @c false if the wrapper has no target, @c true otherwise
-   *
-   *  This function will not throw an exception.
-   */
-  template<typename _Signature>
-    inline bool
-    operator!=(const function<_Signature>& __f, _M_clear_type*)
-    {
-      return __f;
-    }
-
-  /**
-   *  @overload
-   */
-  template<typename _Signature>
-    inline bool
-    operator!=(_M_clear_type*, const function<_Signature>& __f)
-    {
-      return __f;
-    }
-
-  // [3.7.2.8] specialized algorithms
-
-  /**
-   *  @brief Swap the targets of two polymorphic function object wrappers.
-   *
-   *  This function will not throw an exception.
-   */
-  template<typename _Signature>
-    inline void
-    swap(function<_Signature>& __x, function<_Signature>& __y)
-    {
-      __x.swap(__y);
-    }
-
-_GLIBCXX_END_NAMESPACE
-}
-
-#include <tr1/functional_hash.h>
-
-#endif
+#endif // _GLIBCXX_TR1_FUNCTIONAL
diff --git a/libstdc++-v3/include/tr1/functional_hash.h b/libstdc++-v3/include/tr1/functional_hash.h
index f692308..a41b232 100644
--- a/libstdc++-v3/include/tr1/functional_hash.h
+++ b/libstdc++-v3/include/tr1/functional_hash.h
@@ -1,4 +1,4 @@
-// TR1 functional -*- C++ -*-
+// TR1 functional_hash.h header -*- C++ -*-
 
 // Copyright (C) 2007 Free Software Foundation, Inc.
 //
@@ -32,200 +32,27 @@
  *  You should not attempt to use it directly.
  */
 
-#ifndef _TR1_FUNCTIONAL_HASH_H
-#define _TR1_FUNCTIONAL_HASH_H 1
+#ifndef _GLIBCXX_TR1_FUNCTIONAL_HASH_H
+#define _GLIBCXX_TR1_FUNCTIONAL_HASH_H 1
 
-#include <string>
-#include <cmath>  // for std::frexp
+#pragma GCC system_header
 
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-  // Definition of default hash function std::tr1::hash<>.  The types for
-  // which std::tr1::hash<T> is defined is in clause 6.3.3. of the PDTR.
-  template<typename T>
-    struct hash;
-
-#define _TR1_hashtable_define_trivial_hash(_Tp)         \
-  template<>                                            \
-    struct hash<_Tp>                                    \
-    : public std::unary_function<_Tp, std::size_t>      \
-    {                                                   \
-      std::size_t                                       \
-      operator()(_Tp __val) const                       \
-      { return static_cast<std::size_t>(__val); }       \
-    }                                                     
-
-  _TR1_hashtable_define_trivial_hash(bool);
-  _TR1_hashtable_define_trivial_hash(char);
-  _TR1_hashtable_define_trivial_hash(signed char);
-  _TR1_hashtable_define_trivial_hash(unsigned char);
-  _TR1_hashtable_define_trivial_hash(wchar_t);
-  _TR1_hashtable_define_trivial_hash(short);
-  _TR1_hashtable_define_trivial_hash(int);
-  _TR1_hashtable_define_trivial_hash(long);
-  _TR1_hashtable_define_trivial_hash(long long);
-  _TR1_hashtable_define_trivial_hash(unsigned short);
-  _TR1_hashtable_define_trivial_hash(unsigned int);
-  _TR1_hashtable_define_trivial_hash(unsigned long);
-  _TR1_hashtable_define_trivial_hash(unsigned long long);
-
-#undef _TR1_hashtable_define_trivial_hash
-
-  template<typename _Tp>
-    struct hash<_Tp*>
-    : public std::unary_function<_Tp*, std::size_t>
-    {
-      std::size_t
-      operator()(_Tp* __p) const
-      { return reinterpret_cast<std::size_t>(__p); }
-    };
-
-  // Fowler / Noll / Vo (FNV) Hash (type FNV-1a)
-  // (used by the next specializations of std::tr1::hash<>)
-
-  // Dummy generic implementation (for sizeof(size_t) != 4, 8).
-  template<std::size_t = sizeof(std::size_t)>
-    struct _Fnv_hash
-    {
-      static std::size_t
-      hash(const char* __first, std::size_t __length)
-      {
-	std::size_t __result = 0;
-	for (; __length > 0; --__length)
-	  __result = (__result * 131) + *__first++;
-	return __result;
-      }
-    };
-
-  template<>
-    struct _Fnv_hash<4>
-    {
-      static std::size_t
-      hash(const char* __first, std::size_t __length)
-      {
-	std::size_t __result = static_cast<std::size_t>(2166136261UL);
-	for (; __length > 0; --__length)
-	  {
-	    __result ^= static_cast<std::size_t>(*__first++);
-	    __result *= static_cast<std::size_t>(16777619UL);
-	  }
-	return __result;
-      }
-    };
-  
-  template<>
-    struct _Fnv_hash<8>
-    {
-      static std::size_t
-      hash(const char* __first, std::size_t __length)
-      {
-	std::size_t __result =
-	  static_cast<std::size_t>(14695981039346656037ULL);
-	for (; __length > 0; --__length)
-	  {
-	    __result ^= static_cast<std::size_t>(*__first++);
-	    __result *= static_cast<std::size_t>(1099511628211ULL);
-	  }
-	return __result;
-      }
-    };
-
-  // XXX String and floating point hashes probably shouldn't be inline
-  // member functions, since are nontrivial.  Once we have the framework
-  // for TR1 .cc files, these should go in one.
-  template<>
-    struct hash<std::string>
-    : public std::unary_function<std::string, std::size_t>
-    {      
-      std::size_t
-      operator()(const std::string& __s) const
-      { return _Fnv_hash<>::hash(__s.data(), __s.length()); }
-    };
-
-#ifdef _GLIBCXX_USE_WCHAR_T
-  template<>
-    struct hash<std::wstring>
-    : public std::unary_function<std::wstring, std::size_t>
-    {
-      std::size_t
-      operator()(const std::wstring& __s) const
-      {
-	return _Fnv_hash<>::hash(reinterpret_cast<const char*>(__s.data()),
-				 __s.length() * sizeof(wchar_t));
-      }
-    };
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
 #endif
 
-  template<>
-    struct hash<float>
-    : public std::unary_function<float, std::size_t>
-    {
-      std::size_t
-      operator()(float __fval) const
-      {
-	std::size_t __result = 0;
-
-	// 0 and -0 both hash to zero.
-	if (__fval != 0.0f)
-	  __result = _Fnv_hash<>::hash(reinterpret_cast<const char*>(&__fval),
-				       sizeof(__fval));
-	return __result;
-      }
-    };
-
-  template<>
-    struct hash<double>
-    : public std::unary_function<double, std::size_t>
-    {
-      std::size_t
-      operator()(double __dval) const
-      {
-	std::size_t __result = 0;
-
-	// 0 and -0 both hash to zero.
-	if (__dval != 0.0)
-	  __result = _Fnv_hash<>::hash(reinterpret_cast<const char*>(&__dval),
-				       sizeof(__dval));
-	return __result;
-      }
-    };
-
-  // For long double, careful with random padding bits (e.g., on x86,
-  // 10 bytes -> 12 bytes) and resort to frexp.
-  template<>
-    struct hash<long double>
-    : public std::unary_function<long double, std::size_t>
-    {
-      std::size_t
-      operator()(long double __ldval) const
-      {
-	std::size_t __result = 0;
-
-	int __exponent;
-	__ldval = std::frexp(__ldval, &__exponent);
-	__ldval = __ldval < 0.0l ? -(__ldval + 0.5l) : __ldval;
-
-	const long double __mult =
-	  __gnu_cxx::__numeric_traits<std::size_t>::__max + 1.0l;
-	__ldval *= __mult;
-
-	// Try to use all the bits of the mantissa (really necessary only
-	// on 32-bit targets, at least for 80-bit floating point formats).
-	const std::size_t __hibits = (std::size_t)__ldval;
-	__ldval = (__ldval - (long double)__hibits) * __mult;
-
-	const std::size_t __coeff =
-	  __gnu_cxx::__numeric_traits<std::size_t>::__max / __LDBL_MAX_EXP__;
-
-	__result = __hibits + (std::size_t)__ldval + __coeff * __exponent;
-
-	return __result;
-      }
-    };
-
-_GLIBCXX_END_NAMESPACE
-}
-
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/functional_hash.h>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/functional_hash.h>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
 #endif
+
+#endif // _GLIBCXX_TR1_FUNCTIONAL_HASH_H
diff --git a/libstdc++-v3/include/tr1/gamma.tcc b/libstdc++-v3/include/tr1/gamma.tcc
index 407bafc..06702e3 100644
--- a/libstdc++-v3/include/tr1/gamma.tcc
+++ b/libstdc++-v3/include/tr1/gamma.tcc
@@ -56,7 +56,8 @@
 
 namespace std
 {
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
 
   /**
    * @ingroup tr1_math_spec_func
@@ -295,9 +296,9 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
                       = std::numeric_limits<_Tp>::max_exponent10
                       * std::log(_Tp(10)) - _Tp(1);
 #if _GLIBCXX_USE_C99_MATH_TR1
-      _Tp __coeff =  std::_GLIBCXX_TR1::lgamma(_Tp(1 + __n))
-                  - std::_GLIBCXX_TR1::lgamma(_Tp(1 + __k))
-                  - std::_GLIBCXX_TR1::lgamma(_Tp(1 + __n - __k));
+      _Tp __coeff =  std::tr1::lgamma(_Tp(1 + __n))
+                  - std::tr1::lgamma(_Tp(1 + __k))
+                  - std::tr1::lgamma(_Tp(1 + __n - __k));
 #else
       _Tp __coeff =  __log_gamma(_Tp(1 + __n))
                   - __log_gamma(_Tp(1 + __k))
@@ -464,7 +465,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
         {
           const _Tp __hzeta = __hurwitz_zeta(_Tp(__n + 1), __x);
 #if _GLIBCXX_USE_C99_MATH_TR1
-          const _Tp __ln_nfact = std::_GLIBCXX_TR1::lgamma(_Tp(__n + 1));
+          const _Tp __ln_nfact = std::tr1::lgamma(_Tp(__n + 1));
 #else
           const _Tp __ln_nfact = __log_gamma(_Tp(__n + 1));
 #endif
@@ -479,7 +480,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 
   /* @} */ // group tr1_math_spec_func
 
-_GLIBCXX_END_NAMESPACE
+}
 }
 
 #endif // _TR1_GAMMA_TCC
diff --git a/libstdc++-v3/include/tr1/hashtable.h b/libstdc++-v3/include/tr1/hashtable.h
new file mode 100644
index 0000000..b7cf83e
--- /dev/null
+++ b/libstdc++-v3/include/tr1/hashtable.h
@@ -0,0 +1,58 @@
+// TR1 hashtable.h header -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/hashtable.h
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+#ifndef _GLIBCXX_TR1_HASHTABLE_H
+#define _GLIBCXX_TR1_HASHTABLE_H 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/hashtable>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/hashtable>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
+#endif
+
+#endif // _GLIBCXX_TR1_HASHTABLE_H
diff --git a/libstdc++-v3/include/tr1/hypergeometric.tcc b/libstdc++-v3/include/tr1/hypergeometric.tcc
index c0d676f..17fa959 100644
--- a/libstdc++-v3/include/tr1/hypergeometric.tcc
+++ b/libstdc++-v3/include/tr1/hypergeometric.tcc
@@ -44,12 +44,13 @@
 //       Section 6, pp. 555-566
 //   (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
 
-#ifndef _TR1_HYPERGEOMETRIC_TCC
-#define _TR1_HYPERGEOMETRIC_TCC 1
+#ifndef _GLIBCXX_TR1_HYPERGEOMETRIC_TCC
+#define _GLIBCXX_TR1_HYPERGEOMETRIC_TCC 1
 
 namespace std
 {
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
 
   // [5.2] Special functions
 
@@ -233,7 +234,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
     __conf_hyperg(const _Tp __a, const _Tp __c, const _Tp __x)
     {
 #if _GLIBCXX_USE_C99_MATH_TR1
-      const _Tp __c_nint = std::_GLIBCXX_TR1::nearbyint(__c);
+      const _Tp __c_nint = std::tr1::nearbyint(__c);
 #else
       const _Tp __c_nint = static_cast<int>(__c + _Tp(0.5L));
 #endif
@@ -735,9 +736,9 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
     __hyperg(const _Tp __a, const _Tp __b, const _Tp __c, const _Tp __x)
     {
 #if _GLIBCXX_USE_C99_MATH_TR1
-      const _Tp __a_nint = std::_GLIBCXX_TR1::nearbyint(__a);
-      const _Tp __b_nint = std::_GLIBCXX_TR1::nearbyint(__b);
-      const _Tp __c_nint = std::_GLIBCXX_TR1::nearbyint(__c);
+      const _Tp __a_nint = std::tr1::nearbyint(__a);
+      const _Tp __b_nint = std::tr1::nearbyint(__b);
+      const _Tp __c_nint = std::tr1::nearbyint(__c);
 #else
       const _Tp __a_nint = static_cast<int>(__a + _Tp(0.5L));
       const _Tp __b_nint = static_cast<int>(__b + _Tp(0.5L));
@@ -782,7 +783,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 
   /* @} */ // group tr1_math_spec_func
 
-_GLIBCXX_END_NAMESPACE
+}
 }
 
-#endif // _TR1_HYPERGEOMETRIC_TCC
+#endif // _GLIBCXX_TR1_HYPERGEOMETRIC_TCC
diff --git a/libstdc++-v3/include/tr1/inttypes.h b/libstdc++-v3/include/tr1/inttypes.h
index 720089c..3253247 100644
--- a/libstdc++-v3/include/tr1/inttypes.h
+++ b/libstdc++-v3/include/tr1/inttypes.h
@@ -1,6 +1,6 @@
 // TR1 inttypes.h -*- C++ -*-
 
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -31,9 +31,9 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_INTTYPES_H
-#define _TR1_INTTYPES_H 1
+#ifndef _GLIBCXX_TR1_INTTYPES_H
+#define _GLIBCXX_TR1_INTTYPES_H 1
 
 #include <tr1/cinttypes>
 
-#endif
+#endif // _GLIBCXX_TR1_INTTYPES_H
diff --git a/libstdc++-v3/include/tr1/legendre_function.tcc b/libstdc++-v3/include/tr1/legendre_function.tcc
index 323bd18..839459f 100644
--- a/libstdc++-v3/include/tr1/legendre_function.tcc
+++ b/libstdc++-v3/include/tr1/legendre_function.tcc
@@ -47,14 +47,15 @@
 //       W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
 //       2nd ed, pp. 252-254
 
-#ifndef _TR1_LEGENDRE_FUNCTION_TCC
-#define _TR1_LEGENDRE_FUNCTION_TCC 1
+#ifndef _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC
+#define _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC 1
 
 #include "special_function_util.h"
 
 namespace std
 {
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
 
   // [5.2] Special functions
 
@@ -256,14 +257,14 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
           const _Tp __sgn = ( __m % 2 == 1 ? -_Tp(1) : _Tp(1));
           const _Tp __y_mp1m_factor = __x * std::sqrt(_Tp(2 * __m + 3));
 #if _GLIBCXX_USE_C99_MATH_TR1
-          const _Tp __lncirc = std::_GLIBCXX_TR1::log1p(-__x * __x);
+          const _Tp __lncirc = std::tr1::log1p(-__x * __x);
 #else
           const _Tp __lncirc = std::log(_Tp(1) - __x * __x);
 #endif
           //  Gamma(m+1/2) / Gamma(m)
 #if _GLIBCXX_USE_C99_MATH_TR1
-          const _Tp __lnpoch = std::_GLIBCXX_TR1::lgamma(_Tp(__m + _Tp(0.5L)))
-                             - std::_GLIBCXX_TR1::lgamma(_Tp(__m));
+          const _Tp __lnpoch = std::tr1::lgamma(_Tp(__m + _Tp(0.5L)))
+                             - std::tr1::lgamma(_Tp(__m));
 #else
           const _Tp __lnpoch = __log_gamma(_Tp(__m + _Tp(0.5L)))
                              - __log_gamma(_Tp(__m));
@@ -312,7 +313,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 
   /* @} */ // group tr1_math_spec_func
 
-_GLIBCXX_END_NAMESPACE
+}
 }
 
-#endif // _TR1_LEGENDRE_FUNCTION_TCC
+#endif // _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC
diff --git a/libstdc++-v3/include/tr1/math.h b/libstdc++-v3/include/tr1/math.h
index 0698cb2..4e95b9b 100644
--- a/libstdc++-v3/include/tr1/math.h
+++ b/libstdc++-v3/include/tr1/math.h
@@ -31,161 +31,161 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_MATH_H
-#define _TR1_MATH_H 1
+#ifndef _GLIBCXX_TR1_MATH_H
+#define _GLIBCXX_TR1_MATH_H 1
 
 #include <tr1/cmath>
 
 #if _GLIBCXX_USE_C99_MATH_TR1
 
-using std::_GLIBCXX_TR1::acos;
-using std::_GLIBCXX_TR1::acosh;
-using std::_GLIBCXX_TR1::asin;
-using std::_GLIBCXX_TR1::asinh;
-using std::_GLIBCXX_TR1::atan;
-using std::_GLIBCXX_TR1::atan2;
-using std::_GLIBCXX_TR1::atanh;
-using std::_GLIBCXX_TR1::cbrt;
-using std::_GLIBCXX_TR1::ceil;
-using std::_GLIBCXX_TR1::copysign;
-using std::_GLIBCXX_TR1::cos;
-using std::_GLIBCXX_TR1::cosh;
-using std::_GLIBCXX_TR1::erf;
-using std::_GLIBCXX_TR1::erfc;
-using std::_GLIBCXX_TR1::exp;
-using std::_GLIBCXX_TR1::exp2;
-using std::_GLIBCXX_TR1::expm1;
-using std::_GLIBCXX_TR1::fabs;
-using std::_GLIBCXX_TR1::fdim;
-using std::_GLIBCXX_TR1::floor;
-using std::_GLIBCXX_TR1::fma;
-using std::_GLIBCXX_TR1::fmax;
-using std::_GLIBCXX_TR1::fmin;
-using std::_GLIBCXX_TR1::fmod;
-using std::_GLIBCXX_TR1::frexp;
-using std::_GLIBCXX_TR1::hypot;
-using std::_GLIBCXX_TR1::ilogb;
-using std::_GLIBCXX_TR1::ldexp;
-using std::_GLIBCXX_TR1::lgamma;
-using std::_GLIBCXX_TR1::llrint;
-using std::_GLIBCXX_TR1::llround;
-using std::_GLIBCXX_TR1::log;
-using std::_GLIBCXX_TR1::log10;
-using std::_GLIBCXX_TR1::log1p;
-using std::_GLIBCXX_TR1::log2;
-using std::_GLIBCXX_TR1::logb;
-using std::_GLIBCXX_TR1::lrint;
-using std::_GLIBCXX_TR1::lround;
-using std::_GLIBCXX_TR1::nearbyint;
-using std::_GLIBCXX_TR1::nextafter;
-using std::_GLIBCXX_TR1::nexttoward;
-using std::_GLIBCXX_TR1::pow;
-using std::_GLIBCXX_TR1::remainder;
-using std::_GLIBCXX_TR1::remquo;
-using std::_GLIBCXX_TR1::rint;
-using std::_GLIBCXX_TR1::round;
-using std::_GLIBCXX_TR1::scalbln;
-using std::_GLIBCXX_TR1::scalbn;
-using std::_GLIBCXX_TR1::sin;
-using std::_GLIBCXX_TR1::sinh;
-using std::_GLIBCXX_TR1::sqrt;
-using std::_GLIBCXX_TR1::tan;
-using std::_GLIBCXX_TR1::tanh;
-using std::_GLIBCXX_TR1::tgamma;
-using std::_GLIBCXX_TR1::trunc;
+using std::tr1::acos;
+using std::tr1::acosh;
+using std::tr1::asin;
+using std::tr1::asinh;
+using std::tr1::atan;
+using std::tr1::atan2;
+using std::tr1::atanh;
+using std::tr1::cbrt;
+using std::tr1::ceil;
+using std::tr1::copysign;
+using std::tr1::cos;
+using std::tr1::cosh;
+using std::tr1::erf;
+using std::tr1::erfc;
+using std::tr1::exp;
+using std::tr1::exp2;
+using std::tr1::expm1;
+using std::tr1::fabs;
+using std::tr1::fdim;
+using std::tr1::floor;
+using std::tr1::fma;
+using std::tr1::fmax;
+using std::tr1::fmin;
+using std::tr1::fmod;
+using std::tr1::frexp;
+using std::tr1::hypot;
+using std::tr1::ilogb;
+using std::tr1::ldexp;
+using std::tr1::lgamma;
+using std::tr1::llrint;
+using std::tr1::llround;
+using std::tr1::log;
+using std::tr1::log10;
+using std::tr1::log1p;
+using std::tr1::log2;
+using std::tr1::logb;
+using std::tr1::lrint;
+using std::tr1::lround;
+using std::tr1::nearbyint;
+using std::tr1::nextafter;
+using std::tr1::nexttoward;
+using std::tr1::pow;
+using std::tr1::remainder;
+using std::tr1::remquo;
+using std::tr1::rint;
+using std::tr1::round;
+using std::tr1::scalbln;
+using std::tr1::scalbn;
+using std::tr1::sin;
+using std::tr1::sinh;
+using std::tr1::sqrt;
+using std::tr1::tan;
+using std::tr1::tanh;
+using std::tr1::tgamma;
+using std::tr1::trunc;
 
 #endif
 
-using std::_GLIBCXX_TR1::assoc_laguerref;
-using std::_GLIBCXX_TR1::assoc_laguerre;
-using std::_GLIBCXX_TR1::assoc_laguerrel;
+using std::tr1::assoc_laguerref;
+using std::tr1::assoc_laguerre;
+using std::tr1::assoc_laguerrel;
 
-using std::_GLIBCXX_TR1::assoc_legendref;
-using std::_GLIBCXX_TR1::assoc_legendre;
-using std::_GLIBCXX_TR1::assoc_legendrel;
+using std::tr1::assoc_legendref;
+using std::tr1::assoc_legendre;
+using std::tr1::assoc_legendrel;
 
-using std::_GLIBCXX_TR1::betaf;
-using std::_GLIBCXX_TR1::beta;
-using std::_GLIBCXX_TR1::betal;
+using std::tr1::betaf;
+using std::tr1::beta;
+using std::tr1::betal;
 
-using std::_GLIBCXX_TR1::comp_ellint_1f;
-using std::_GLIBCXX_TR1::comp_ellint_1;
-using std::_GLIBCXX_TR1::comp_ellint_1l;
+using std::tr1::comp_ellint_1f;
+using std::tr1::comp_ellint_1;
+using std::tr1::comp_ellint_1l;
 
-using std::_GLIBCXX_TR1::comp_ellint_2f;
-using std::_GLIBCXX_TR1::comp_ellint_2;
-using std::_GLIBCXX_TR1::comp_ellint_2l;
+using std::tr1::comp_ellint_2f;
+using std::tr1::comp_ellint_2;
+using std::tr1::comp_ellint_2l;
 
-using std::_GLIBCXX_TR1::comp_ellint_3f;
-using std::_GLIBCXX_TR1::comp_ellint_3;
-using std::_GLIBCXX_TR1::comp_ellint_3l;
+using std::tr1::comp_ellint_3f;
+using std::tr1::comp_ellint_3;
+using std::tr1::comp_ellint_3l;
 
-using std::_GLIBCXX_TR1::conf_hypergf;
-using std::_GLIBCXX_TR1::conf_hyperg;
-using std::_GLIBCXX_TR1::conf_hypergl;
+using std::tr1::conf_hypergf;
+using std::tr1::conf_hyperg;
+using std::tr1::conf_hypergl;
 
-using std::_GLIBCXX_TR1::cyl_bessel_if;
-using std::_GLIBCXX_TR1::cyl_bessel_i;
-using std::_GLIBCXX_TR1::cyl_bessel_il;
+using std::tr1::cyl_bessel_if;
+using std::tr1::cyl_bessel_i;
+using std::tr1::cyl_bessel_il;
 
-using std::_GLIBCXX_TR1::cyl_bessel_jf;
-using std::_GLIBCXX_TR1::cyl_bessel_j;
-using std::_GLIBCXX_TR1::cyl_bessel_jl;
+using std::tr1::cyl_bessel_jf;
+using std::tr1::cyl_bessel_j;
+using std::tr1::cyl_bessel_jl;
 
-using std::_GLIBCXX_TR1::cyl_bessel_kf;
-using std::_GLIBCXX_TR1::cyl_bessel_k;
-using std::_GLIBCXX_TR1::cyl_bessel_kl;
+using std::tr1::cyl_bessel_kf;
+using std::tr1::cyl_bessel_k;
+using std::tr1::cyl_bessel_kl;
 
-using std::_GLIBCXX_TR1::cyl_neumannf;
-using std::_GLIBCXX_TR1::cyl_neumann;
-using std::_GLIBCXX_TR1::cyl_neumannl;
+using std::tr1::cyl_neumannf;
+using std::tr1::cyl_neumann;
+using std::tr1::cyl_neumannl;
 
-using std::_GLIBCXX_TR1::ellint_1f;
-using std::_GLIBCXX_TR1::ellint_1;
-using std::_GLIBCXX_TR1::ellint_1l;
+using std::tr1::ellint_1f;
+using std::tr1::ellint_1;
+using std::tr1::ellint_1l;
 
-using std::_GLIBCXX_TR1::ellint_2f;
-using std::_GLIBCXX_TR1::ellint_2;
-using std::_GLIBCXX_TR1::ellint_2l;
+using std::tr1::ellint_2f;
+using std::tr1::ellint_2;
+using std::tr1::ellint_2l;
 
-using std::_GLIBCXX_TR1::ellint_3f;
-using std::_GLIBCXX_TR1::ellint_3;
-using std::_GLIBCXX_TR1::ellint_3l;
+using std::tr1::ellint_3f;
+using std::tr1::ellint_3;
+using std::tr1::ellint_3l;
 
-using std::_GLIBCXX_TR1::expintf;
-using std::_GLIBCXX_TR1::expint;
-using std::_GLIBCXX_TR1::expintl;
+using std::tr1::expintf;
+using std::tr1::expint;
+using std::tr1::expintl;
 
-using std::_GLIBCXX_TR1::hermitef;
-using std::_GLIBCXX_TR1::hermite;
-using std::_GLIBCXX_TR1::hermitel;
+using std::tr1::hermitef;
+using std::tr1::hermite;
+using std::tr1::hermitel;
 
-using std::_GLIBCXX_TR1::hypergf;
-using std::_GLIBCXX_TR1::hyperg;
-using std::_GLIBCXX_TR1::hypergl;
+using std::tr1::hypergf;
+using std::tr1::hyperg;
+using std::tr1::hypergl;
 
-using std::_GLIBCXX_TR1::laguerref;
-using std::_GLIBCXX_TR1::laguerre;
-using std::_GLIBCXX_TR1::laguerrel;
+using std::tr1::laguerref;
+using std::tr1::laguerre;
+using std::tr1::laguerrel;
 
-using std::_GLIBCXX_TR1::legendref;
-using std::_GLIBCXX_TR1::legendre;
-using std::_GLIBCXX_TR1::legendrel;
+using std::tr1::legendref;
+using std::tr1::legendre;
+using std::tr1::legendrel;
 
-using std::_GLIBCXX_TR1::riemann_zetaf;
-using std::_GLIBCXX_TR1::riemann_zeta;
-using std::_GLIBCXX_TR1::riemann_zetal;
+using std::tr1::riemann_zetaf;
+using std::tr1::riemann_zeta;
+using std::tr1::riemann_zetal;
 
-using std::_GLIBCXX_TR1::sph_besself;
-using std::_GLIBCXX_TR1::sph_bessel;
-using std::_GLIBCXX_TR1::sph_bessell;
+using std::tr1::sph_besself;
+using std::tr1::sph_bessel;
+using std::tr1::sph_bessell;
 
-using std::_GLIBCXX_TR1::sph_legendref;
-using std::_GLIBCXX_TR1::sph_legendre;
-using std::_GLIBCXX_TR1::sph_legendrel;
+using std::tr1::sph_legendref;
+using std::tr1::sph_legendre;
+using std::tr1::sph_legendrel;
 
-using std::_GLIBCXX_TR1::sph_neumannf;
-using std::_GLIBCXX_TR1::sph_neumann;
-using std::_GLIBCXX_TR1::sph_neumannl;
+using std::tr1::sph_neumannf;
+using std::tr1::sph_neumann;
+using std::tr1::sph_neumannl;
 
-#endif
+#endif // _GLIBCXX_TR1_MATH_H
diff --git a/libstdc++-v3/include/tr1/memory b/libstdc++-v3/include/tr1/memory
index f397c98..69f2f57 100644
--- a/libstdc++-v3/include/tr1/memory
+++ b/libstdc++-v3/include/tr1/memory
@@ -32,24 +32,40 @@
  * This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_MEMORY
-#define _TR1_MEMORY 1
+#ifndef _GLIBCXX_TR1_MEMORY
+#define _GLIBCXX_TR1_MEMORY 1
 
-#include <cstddef>          	// std::size_t
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
+
+#include <memory>
 #include <exception>        	// std::exception
 #include <new>              	// std::bad_alloc
 #include <typeinfo>         	// std::type_info in get_deleter
 #include <bits/stl_algobase.h>  // std::swap
 #include <iosfwd>           	// std::basic_ostream
-#include <memory>
-
 #include <ext/atomicity.h>
 #include <ext/concurrence.h>
 #include <bits/functexcept.h>
 #include <bits/stl_function.h> 	// std::less
 #include <debug/debug.h>
+#include <tr1/type_traits>
 
-#include <tr1/type_traits>  	// tr1::add_reference
-#include <tr1/boost_shared_ptr.h>
-
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/boost_shared_ptr.h>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/boost_shared_ptr.h>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
 #endif
+
+#endif // _GLIBCXX_TR1_MEMORY
diff --git a/libstdc++-v3/include/tr1/modified_bessel_func.tcc b/libstdc++-v3/include/tr1/modified_bessel_func.tcc
index c7065a2..912f99f 100644
--- a/libstdc++-v3/include/tr1/modified_bessel_func.tcc
+++ b/libstdc++-v3/include/tr1/modified_bessel_func.tcc
@@ -49,14 +49,15 @@
 //       W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
 //       2nd ed, pp. 246-249.
 
-#ifndef _TR1_MODIFIED_BESSEL_FUNC_TCC
-#define _TR1_MODIFIED_BESSEL_FUNC_TCC 1
+#ifndef _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC
+#define _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC 1
 
 #include "special_function_util.h"
 
 namespace std
 {
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
 
   // [5.2] Special functions
 
@@ -444,7 +445,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 
   /* @} */ // group tr1_math_spec_func
 
-_GLIBCXX_END_NAMESPACE
+}
 }
 
-#endif // _TR1_MODIFIED_BESSEL_FUNC_TCC
+#endif // _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC
diff --git a/libstdc++-v3/include/tr1/poly_hermite.tcc b/libstdc++-v3/include/tr1/poly_hermite.tcc
index 3a7bf92..2d8ccfe 100644
--- a/libstdc++-v3/include/tr1/poly_hermite.tcc
+++ b/libstdc++-v3/include/tr1/poly_hermite.tcc
@@ -42,12 +42,13 @@
 //       Ed. Milton Abramowitz and Irene A. Stegun,
 //       Dover Publications, Section 22 pp. 773-802
 
-#ifndef _TR1_POLY_HERMITE_TCC
-#define _TR1_POLY_HERMITE_TCC 1
+#ifndef _GLIBCXX_TR1_POLY_HERMITE_TCC
+#define _GLIBCXX_TR1_POLY_HERMITE_TCC 1
 
 namespace std
 {
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
 
   // [5.2] Special functions
 
@@ -132,7 +133,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 
   /* @} */ // group tr1_math_spec_func
 
-_GLIBCXX_END_NAMESPACE
+}
 }
 
-#endif // _TR1_POLY_HERMITE_TCC
+#endif // _GLIBCXX_TR1_POLY_HERMITE_TCC
diff --git a/libstdc++-v3/include/tr1/poly_laguerre.tcc b/libstdc++-v3/include/tr1/poly_laguerre.tcc
index b99d092..46c51a5 100644
--- a/libstdc++-v3/include/tr1/poly_laguerre.tcc
+++ b/libstdc++-v3/include/tr1/poly_laguerre.tcc
@@ -44,12 +44,13 @@
 //       Section 13, pp. 509-510, Section 22 pp. 773-802
 //   (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
 
-#ifndef _TR1_POLY_LAGUERRE_TCC
-#define _TR1_POLY_LAGUERRE_TCC 1
+#ifndef _GLIBCXX_TR1_POLY_LAGUERRE_TCC
+#define _GLIBCXX_TR1_POLY_LAGUERRE_TCC 1
 
 namespace std
 {
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
 
   // [5.2] Special functions
 
@@ -94,8 +95,8 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
                         * __eta * __eta * __cos2th * __sin2th;
 
 #if _GLIBCXX_USE_C99_MATH_TR1
-      const _Tp __lg_b = std::_GLIBCXX_TR1::lgamma(_Tp(__n) + __b);
-      const _Tp __lnfact = std::_GLIBCXX_TR1::lgamma(_Tp(__n + 1));
+      const _Tp __lg_b = std::tr1::lgamma(_Tp(__n) + __b);
+      const _Tp __lnfact = std::tr1::lgamma(_Tp(__n + 1));
 #else
       const _Tp __lg_b = __log_gamma(_Tp(__n) + __b);
       const _Tp __lnfact = __log_gamma(_Tp(__n + 1));
@@ -337,7 +338,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 
   /* @} */ // group tr1_math_spec_func
 
-_GLIBCXX_END_NAMESPACE
+}
 }
 
-#endif // _TR1_POLY_LAGUERRE_TCC
+#endif // _GLIBCXX_TR1_POLY_LAGUERRE_TCC
diff --git a/libstdc++-v3/include/tr1/random b/libstdc++-v3/include/tr1/random
index 1033743..49a3b21 100644
--- a/libstdc++-v3/include/tr1/random
+++ b/libstdc++-v3/include/tr1/random
@@ -32,8 +32,14 @@
  * This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_RANDOM
-#define _TR1_RANDOM 1
+#ifndef _GLIBCXX_TR1_RANDOM
+#define _GLIBCXX_TR1_RANDOM 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
 
 #include <cmath>
 #include <cstdio>
@@ -41,2326 +47,25 @@
 #include <string>
 #include <iosfwd>
 #include <limits>
-#include <tr1/type_traits>
-#include <tr1/cmath>
 #include <ext/type_traits.h>
 #include <ext/numeric_traits.h>
 #include <bits/concept_check.h>
 #include <debug/debug.h>
+#include <tr1/type_traits>
+#include <tr1/cmath>
 
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-  // [5.1] Random number generation
-
-  /**
-   * @addtogroup tr1_random Random Number Generation
-   * A facility for generating random numbers on selected distributions.
-   * @{
-   */
-
-  /*
-   * Implementation-space details.
-   */
-  namespace __detail
-  {
-    template<typename _UIntType, int __w, 
-	     bool = __w < std::numeric_limits<_UIntType>::digits>
-      struct _Shift
-      { static const _UIntType __value = 0; };
-
-    template<typename _UIntType, int __w>
-      struct _Shift<_UIntType, __w, true>
-      { static const _UIntType __value = _UIntType(1) << __w; };
-
-    template<typename _Tp, _Tp __a, _Tp __c, _Tp __m, bool>
-      struct _Mod;
-
-    // Dispatch based on modulus value to prevent divide-by-zero compile-time
-    // errors when m == 0.
-    template<typename _Tp, _Tp __a, _Tp __c, _Tp __m>
-      inline _Tp
-      __mod(_Tp __x)
-      { return _Mod<_Tp, __a, __c, __m, __m == 0>::__calc(__x); }
-
-    typedef __gnu_cxx::__conditional_type<(sizeof(unsigned) == 4),
-		    unsigned, unsigned long>::__type _UInt32Type;
-
-    /*
-     * An adaptor class for converting the output of any Generator into
-     * the input for a specific Distribution.
-     */
-    template<typename _Engine, typename _Distribution>
-      struct _Adaptor
-      { 
-	typedef typename _Engine::result_type        _Engine_result_type;
-	typedef typename _Distribution::input_type   result_type;
-
-      public:
-	_Adaptor(const _Engine& __g)
-	: _M_g(__g) { }
-
-	result_type
-	min() const
-	{
-	  result_type __return_value = 0;
-	  if (is_integral<_Engine_result_type>::value
-	      && is_integral<result_type>::value)
-	    __return_value = _M_g.min();
-	  else if (!is_integral<result_type>::value)
-	    __return_value = result_type(0);
-	  return __return_value;
-	}
-
-	result_type
-	max() const
-	{
-	  result_type __return_value = 0;
-	  if (is_integral<_Engine_result_type>::value
-	      && is_integral<result_type>::value)
-	    __return_value = _M_g.max();
-	  else if (!is_integral<result_type>::value)
-	    __return_value = result_type(1);
-	  return __return_value;
-	}
-
-	result_type
-	operator()();
-
-      private:
-	_Engine _M_g;
-      };
-
-    /*
-     * Converts a value generated by the adapted random number generator into a
-     * value in the input domain for the dependent random number distribution.
-     *
-     * Because the type traits are compile time constants only the appropriate
-     * clause of the if statements will actually be emitted by the compiler.
-     */
-    template<typename _Engine, typename _Distribution>
-      typename _Adaptor<_Engine, _Distribution>::result_type
-      _Adaptor<_Engine, _Distribution>::
-      operator()()
-      {
-	result_type __return_value = 0;
-	if (is_integral<_Engine_result_type>::value
-	    && is_integral<result_type>::value)
-	  __return_value = _M_g();
-      	else if (is_integral<_Engine_result_type>::value
-		 && !is_integral<result_type>::value)
-	  __return_value = result_type(_M_g() - _M_g.min())
-	    / result_type(_M_g.max() - _M_g.min() + result_type(1));
-	else if (!is_integral<_Engine_result_type>::value
-		 && !is_integral<result_type>::value)
-	  __return_value = result_type(_M_g() - _M_g.min())
-	    / result_type(_M_g.max() - _M_g.min());
-      	return __return_value;
-      }
-  } // namespace __detail
-
-  /**
-   * Produces random numbers on a given disribution function using a un uniform
-   * random number generation engine.
-   *
-   * @todo the engine_value_type needs to be studied more carefully.
-   */
-  template<typename _Engine, typename _Dist>
-    class variate_generator
-    {
-      // Concept requirements.
-      __glibcxx_class_requires(_Engine, _CopyConstructibleConcept)
-      //  __glibcxx_class_requires(_Engine, _EngineConcept)
-      //  __glibcxx_class_requires(_Dist, _EngineConcept)
-
-    public:
-      typedef _Engine                                engine_type;
-      typedef __detail::_Adaptor<_Engine, _Dist>     engine_value_type;
-      typedef _Dist                                  distribution_type;
-      typedef typename _Dist::result_type            result_type;
-
-      // tr1:5.1.1 table 5.1 requirement
-      typedef typename __gnu_cxx::__enable_if<
-	is_arithmetic<result_type>::value, result_type>::__type _IsValidType;
-
-      /**
-       * Constructs a variate generator with the uniform random number
-       * generator @p __eng for the random distribution @p __dist.
-       *
-       * @throws Any exceptions which may thrown by the copy constructors of
-       * the @p _Engine or @p _Dist objects.
-       */
-      variate_generator(engine_type __eng, distribution_type __dist)
-      : _M_engine(__eng), _M_dist(__dist) { }
-
-      /**
-       * Gets the next generated value on the distribution.
-       */
-      result_type
-      operator()()
-      { return _M_dist(_M_engine); }
-
-      /**
-       * WTF?
-       */
-      template<typename _Tp>
-        result_type
-        operator()(_Tp __value)
-        { return _M_dist(_M_engine, __value); }
-
-      /**
-       * Gets a reference to the underlying uniform random number generator
-       * object.
-       */
-      engine_value_type&
-      engine()
-      { return _M_engine; }
-
-      /**
-       * Gets a const reference to the underlying uniform random number
-       * generator object.
-       */
-      const engine_value_type&
-      engine() const
-      { return _M_engine; }
-
-      /**
-       * Gets a reference to the underlying random distribution.
-       */
-      distribution_type&
-      distribution()
-      { return _M_dist; }
-
-      /**
-       * Gets a const reference to the underlying random distribution.
-       */
-      const distribution_type&
-      distribution() const
-      { return _M_dist; }
-
-      /**
-       * Gets the closed lower bound of the distribution interval.
-       */
-      result_type
-      min() const
-      { return this->distribution().min(); }
-
-      /**
-       * Gets the closed upper bound of the distribution interval.
-       */
-      result_type
-      max() const
-      { return this->distribution().max(); }
-
-    private:
-      engine_value_type _M_engine;
-      distribution_type _M_dist;
-    };
-
-
-  /**
-   * @addtogroup tr1_random_generators Random Number Generators
-   * @ingroup tr1_random
-   *
-   * These classes define objects which provide random or pseudorandom
-   * numbers, either from a discrete or a continuous interval.  The
-   * random number generator supplied as a part of this library are
-   * all uniform random number generators which provide a sequence of
-   * random number uniformly distributed over their range.
-   *
-   * A number generator is a function object with an operator() that
-   * takes zero arguments and returns a number.
-   *
-   * A compliant random number generator must satisy the following
-   * requirements.  <table border=1 cellpadding=10 cellspacing=0>
-   * <caption align=top>Random Number Generator Requirements</caption>
-   * <tr><td>To be documented.</td></tr> </table>
-   * 
-   * @{
-   */
-
-  /**
-   * @brief A model of a linear congruential random number generator.
-   *
-   * A random number generator that produces pseudorandom numbers using the
-   * linear function @f$x_{i+1}\leftarrow(ax_{i} + c) \bmod m @f$.
-   *
-   * The template parameter @p _UIntType must be an unsigned integral type
-   * large enough to store values up to (__m-1). If the template parameter
-   * @p __m is 0, the modulus @p __m used is
-   * std::numeric_limits<_UIntType>::max() plus 1. Otherwise, the template
-   * parameters @p __a and @p __c must be less than @p __m.
-   *
-   * The size of the state is @f$ 1 @f$.
-   */
-  template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-    class linear_congruential
-    {
-      __glibcxx_class_requires(_UIntType, _UnsignedIntegerConcept)
-      //  __glibcpp_class_requires(__a < __m && __c < __m)
-
-    public:
-      /** The type of the generated random value. */
-      typedef _UIntType result_type;
-
-      /** The multiplier. */
-      static const _UIntType multiplier = __a;
-      /** An increment. */
-      static const _UIntType increment = __c;
-      /** The modulus. */
-      static const _UIntType modulus = __m;
-
-      /**
-       * Constructs a %linear_congruential random number generator engine with
-       * seed @p __s.  The default seed value is 1.
-       *
-       * @param __s The initial seed value.
-       */
-      explicit
-      linear_congruential(unsigned long __x0 = 1)
-      { this->seed(__x0); }
-
-      /**
-       * Constructs a %linear_congruential random number generator engine
-       * seeded from the generator function @p __g.
-       *
-       * @param __g The seed generator function.
-       */
-      template<class _Gen>
-        linear_congruential(_Gen& __g)
-        { this->seed(__g); }
-
-      /**
-       * Reseeds the %linear_congruential random number generator engine
-       * sequence to the seed @g __s.
-       *
-       * @param __s The new seed.
-       */
-      void
-      seed(unsigned long __s = 1);
-
-      /**
-       * Reseeds the %linear_congruential random number generator engine
-       * sequence using values from the generator function @p __g.
-       *
-       * @param __g the seed generator function.
-       */
-      template<class _Gen>
-        void
-        seed(_Gen& __g)
-        { seed(__g, typename is_fundamental<_Gen>::type()); }
-
-      /**
-       * Gets the smallest possible value in the output range.
-       *
-       * The minumum depends on the @p __c parameter: if it is zero, the
-       * minimum generated must be > 0, otherwise 0 is allowed.
-       */
-      result_type
-      min() const
-      { return (__detail::__mod<_UIntType, 1, 0, __m>(__c) == 0) ? 1 : 0; }
-
-      /**
-       * Gets the largest possible value in the output range.
-       */
-      result_type
-      max() const
-      { return __m - 1; }
-
-      /**
-       * Gets the next random number in the sequence.
-       */
-      result_type
-      operator()();
-
-      /**
-       * Compares two linear congruential random number generator
-       * objects of the same type for equality.
-       *  
-       * @param __lhs A linear congruential random number generator object.
-       * @param __rhs Another linear congruential random number generator obj.
-       *
-       * @returns true if the two objects are equal, false otherwise.
-       */
-      friend bool
-      operator==(const linear_congruential& __lhs,
-		 const linear_congruential& __rhs)
-      { return __lhs._M_x == __rhs._M_x; }
-
-      /**
-       * Compares two linear congruential random number generator
-       * objects of the same type for inequality.
-       *
-       * @param __lhs A linear congruential random number generator object.
-       * @param __rhs Another linear congruential random number generator obj.
-       *
-       * @returns true if the two objects are not equal, false otherwise.
-       */
-      friend bool
-      operator!=(const linear_congruential& __lhs,
-		 const linear_congruential& __rhs)
-      { return !(__lhs == __rhs); }
-
-      /**
-       * Writes the textual representation of the state x(i) of x to @p __os.
-       *
-       * @param __os  The output stream.
-       * @param __lcr A % linear_congruential random number generator.
-       * @returns __os.
-       */
-      template<class _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
-	       _UIntType1 __m1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const linear_congruential<_UIntType1, __a1, __c1,
-		   __m1>& __lcr);
-
-      /**
-       * Sets the state of the engine by reading its textual
-       * representation from @p __is.
-       *
-       * The textual representation must have been previously written using an
-       * output stream whose imbued locale and whose type's template
-       * specialization arguments _CharT and _Traits were the same as those of
-       * @p __is.
-       *
-       * @param __is  The input stream.
-       * @param __lcr A % linear_congruential random number generator.
-       * @returns __is.
-       */
-      template<class _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
-	       _UIntType1 __m1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   linear_congruential<_UIntType1, __a1, __c1, __m1>& __lcr);
-
-    private:
-      template<class _Gen>
-        void
-        seed(_Gen& __g, true_type)
-        { return seed(static_cast<unsigned long>(__g)); }
-
-      template<class _Gen>
-        void
-        seed(_Gen& __g, false_type);
-
-      _UIntType _M_x;
-    };
-
-  /**
-   * The classic Minimum Standard rand0 of Lewis, Goodman, and Miller.
-   */
-  typedef linear_congruential<unsigned long, 16807, 0, 2147483647> minstd_rand0;
-
-  /**
-   * An alternative LCR (Lehmer Generator function) .
-   */
-  typedef linear_congruential<unsigned long, 48271, 0, 2147483647> minstd_rand;
-
-
-  /**
-   * A generalized feedback shift register discrete random number generator.
-   *
-   * This algorithm avoind multiplication and division and is designed to be
-   * friendly to a pipelined architecture.  If the parameters are chosen
-   * correctly, this generator will produce numbers with a very long period and
-   * fairly good apparent entropy, although still not cryptographically strong.
-   *
-   * The best way to use this generator is with the predefined mt19937 class.
-   *
-   * This algorithm was originally invented by Makoto Matsumoto and
-   * Takuji Nishimura.
-   *
-   * @var word_size   The number of bits in each element of the state vector.
-   * @var state_size  The degree of recursion.
-   * @var shift_size  The period parameter.
-   * @var mask_bits   The separation point bit index.
-   * @var parameter_a The last row of the twist matrix.
-   * @var output_u    The first right-shift tempering matrix parameter.
-   * @var output_s    The first left-shift tempering matrix parameter.
-   * @var output_b    The first left-shift tempering matrix mask.
-   * @var output_t    The second left-shift tempering matrix parameter.
-   * @var output_c    The second left-shift tempering matrix mask.
-   * @var output_l    The second right-shift tempering matrix parameter.
-   */
-  template<class _UIntType, int __w, int __n, int __m, int __r,
-	   _UIntType __a, int __u, int __s, _UIntType __b, int __t,
-	   _UIntType __c, int __l>
-    class mersenne_twister
-    {
-      __glibcxx_class_requires(_UIntType, _UnsignedIntegerConcept)
-
-    public:
-      // types
-      typedef _UIntType result_type;
-
-      // parameter values
-      static const int       word_size   = __w;
-      static const int       state_size  = __n;
-      static const int       shift_size  = __m;
-      static const int       mask_bits   = __r;
-      static const _UIntType parameter_a = __a;
-      static const int       output_u    = __u;
-      static const int       output_s    = __s;
-      static const _UIntType output_b    = __b;
-      static const int       output_t    = __t;
-      static const _UIntType output_c    = __c;
-      static const int       output_l    = __l;
-
-      // constructors and member function
-      mersenne_twister()
-      { seed(); }
-
-      explicit
-      mersenne_twister(unsigned long __value)
-      { seed(__value); }
-
-      template<class _Gen>
-        mersenne_twister(_Gen& __g)
-        { seed(__g); }
-
-      void
-      seed()
-      { seed(5489UL); }
-
-      void
-      seed(unsigned long __value);
-
-      template<class _Gen>
-        void
-        seed(_Gen& __g)
-        { seed(__g, typename is_fundamental<_Gen>::type()); }
-
-      result_type
-      min() const
-      { return 0; };
-
-      result_type
-      max() const
-      { return __detail::_Shift<_UIntType, __w>::__value - 1; }
-
-      result_type
-      operator()();
-
-      /**
-       * Compares two % mersenne_twister random number generator objects of
-       * the same type for equality.
-       *
-       * @param __lhs A % mersenne_twister random number generator object.
-       * @param __rhs Another % mersenne_twister random number generator
-       *              object.
-       *
-       * @returns true if the two objects are equal, false otherwise.
-       */
-      friend bool
-      operator==(const mersenne_twister& __lhs,
-		 const mersenne_twister& __rhs)
-      { return std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x); }
-
-      /**
-       * Compares two % mersenne_twister random number generator objects of
-       * the same type for inequality.
-       *
-       * @param __lhs A % mersenne_twister random number generator object.
-       * @param __rhs Another % mersenne_twister random number generator
-       *              object.
-       *
-       * @returns true if the two objects are not equal, false otherwise.
-       */
-      friend bool
-      operator!=(const mersenne_twister& __lhs,
-		 const mersenne_twister& __rhs)
-      { return !(__lhs == __rhs); }
-
-      /**
-       * Inserts the current state of a % mersenne_twister random number
-       * generator engine @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A % mersenne_twister random number generator engine.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<class _UIntType1, int __w1, int __n1, int __m1, int __r1,
-	       _UIntType1 __a1, int __u1, int __s1, _UIntType1 __b1, int __t1,
-	       _UIntType1 __c1, int __l1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const mersenne_twister<_UIntType1, __w1, __n1, __m1, __r1,
-		   __a1, __u1, __s1, __b1, __t1, __c1, __l1>& __x);
-
-      /**
-       * Extracts the current state of a % mersenne_twister random number
-       * generator engine @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A % mersenne_twister random number generator engine.
-       *
-       * @returns The input stream with the state of @p __x extracted or in
-       * an error state.
-       */
-      template<class _UIntType1, int __w1, int __n1, int __m1, int __r1,
-	       _UIntType1 __a1, int __u1, int __s1, _UIntType1 __b1, int __t1,
-	       _UIntType1 __c1, int __l1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   mersenne_twister<_UIntType1, __w1, __n1, __m1, __r1,
-		   __a1, __u1, __s1, __b1, __t1, __c1, __l1>& __x);
-
-    private:
-      template<class _Gen>
-        void
-        seed(_Gen& __g, true_type)
-        { return seed(static_cast<unsigned long>(__g)); }
-
-      template<class _Gen>
-        void
-        seed(_Gen& __g, false_type);
-
-      _UIntType _M_x[state_size];
-      int       _M_p;
-    };
-
-  /**
-   * The classic Mersenne Twister.
-   *
-   * Reference:
-   * M. Matsumoto and T. Nishimura, "Mersenne Twister: A 623-Dimensionally
-   * Equidistributed Uniform Pseudo-Random Number Generator", ACM Transactions
-   * on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30.
-   */
-  typedef mersenne_twister<
-    unsigned long, 32, 624, 397, 31,
-    0x9908b0dful, 11, 7,
-    0x9d2c5680ul, 15,
-    0xefc60000ul, 18
-    > mt19937;
-
-
-  /**
-   * @brief The Marsaglia-Zaman generator.
-   * 
-   * This is a model of a Generalized Fibonacci discrete random number
-   * generator, sometimes referred to as the SWC generator.
-   *
-   * A discrete random number generator that produces pseudorandom
-   * numbers using @f$x_{i}\leftarrow(x_{i - s} - x_{i - r} -
-   * carry_{i-1}) \bmod m @f$.
-   *
-   * The size of the state is @f$ r @f$
-   * and the maximum period of the generator is @f$ m^r - m^s -1 @f$.
-   *
-   * N1688[4.13] says "the template parameter _IntType shall denote an integral
-   * type large enough to store values up to m."
-   *
-   * @if maint
-   * @var _M_x     The state of the generator.  This is a ring buffer.
-   * @var _M_carry The carry.
-   * @var _M_p     Current index of x(i - r).
-   * @endif
-   */
-  template<typename _IntType, _IntType __m, int __s, int __r>
-    class subtract_with_carry
-    {
-      __glibcxx_class_requires(_IntType, _IntegerConcept)
-
-    public:
-      /** The type of the generated random value. */
-      typedef _IntType result_type;
-      
-      // parameter values
-      static const _IntType modulus   = __m;
-      static const int      long_lag  = __r;
-      static const int      short_lag = __s;
-
-      /**
-       * Constructs a default-initialized % subtract_with_carry random number
-       * generator.
-       */
-      subtract_with_carry()
-      { this->seed(); }
-
-      /**
-       * Constructs an explicitly seeded % subtract_with_carry random number
-       * generator.
-       */
-      explicit
-      subtract_with_carry(unsigned long __value)
-      { this->seed(__value); }
-
-      /**
-       * Constructs a %subtract_with_carry random number generator engine
-       * seeded from the generator function @p __g.
-       *
-       * @param __g The seed generator function.
-       */
-      template<class _Gen>
-        subtract_with_carry(_Gen& __g)
-        { this->seed(__g); }
-
-      /**
-       * Seeds the initial state @f$ x_0 @f$ of the random number generator.
-       *
-       * N1688[4.19] modifies this as follows.  If @p __value == 0,
-       * sets value to 19780503.  In any case, with a linear
-       * congruential generator lcg(i) having parameters @f$ m_{lcg} =
-       * 2147483563, a_{lcg} = 40014, c_{lcg} = 0, and lcg(0) = value
-       * @f$, sets @f$ x_{-r} \dots x_{-1} @f$ to @f$ lcg(1) \bmod m
-       * \dots lcg(r) \bmod m @f$ respectively.  If @f$ x_{-1} = 0 @f$
-       * set carry to 1, otherwise sets carry to 0.
-       */
-      void
-      seed(unsigned long __value = 19780503);
-
-      /**
-       * Seeds the initial state @f$ x_0 @f$ of the % subtract_with_carry
-       * random number generator.
-       */
-      template<class _Gen>
-        void
-        seed(_Gen& __g)
-        { seed(__g, typename is_fundamental<_Gen>::type()); }
-
-      /**
-       * Gets the inclusive minimum value of the range of random integers
-       * returned by this generator.
-       */
-      result_type
-      min() const
-      { return 0; }
-
-      /**
-       * Gets the inclusive maximum value of the range of random integers
-       * returned by this generator.
-       */
-      result_type
-      max() const
-      { return this->modulus - 1; }
-
-      /**
-       * Gets the next random number in the sequence.
-       */
-      result_type
-      operator()();
-
-      /**
-       * Compares two % subtract_with_carry random number generator objects of
-       * the same type for equality.
-       *
-       * @param __lhs A % subtract_with_carry random number generator object.
-       * @param __rhs Another % subtract_with_carry random number generator
-       *              object.
-       *
-       * @returns true if the two objects are equal, false otherwise.
-       */
-      friend bool
-      operator==(const subtract_with_carry& __lhs,
-		 const subtract_with_carry& __rhs)
-      { return std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x); }
-
-      /**
-       * Compares two % subtract_with_carry random number generator objects of
-       * the same type for inequality.
-       *
-       * @param __lhs A % subtract_with_carry random number generator object.
-       * @param __rhs Another % subtract_with_carry random number generator
-       *              object.
-       *
-       * @returns true if the two objects are not equal, false otherwise.
-       */
-      friend bool
-      operator!=(const subtract_with_carry& __lhs,
-		 const subtract_with_carry& __rhs)
-      { return !(__lhs == __rhs); }
-
-      /**
-       * Inserts the current state of a % subtract_with_carry random number
-       * generator engine @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A % subtract_with_carry random number generator engine.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _IntType1, _IntType1 __m1, int __s1, int __r1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const subtract_with_carry<_IntType1, __m1, __s1,
-		   __r1>& __x);
-
-      /**
-       * Extracts the current state of a % subtract_with_carry random number
-       * generator engine @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A % subtract_with_carry random number generator engine.
-       *
-       * @returns The input stream with the state of @p __x extracted or in
-       * an error state.
-       */
-      template<typename _IntType1, _IntType1 __m1, int __s1, int __r1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   subtract_with_carry<_IntType1, __m1, __s1, __r1>& __x);
-
-    private:
-      template<class _Gen>
-        void
-        seed(_Gen& __g, true_type)
-        { return seed(static_cast<unsigned long>(__g)); }
-
-      template<class _Gen>
-        void
-        seed(_Gen& __g, false_type);
-
-      typedef typename __gnu_cxx::__add_unsigned<_IntType>::__type _UIntType;
-
-      _UIntType  _M_x[long_lag];
-      _UIntType  _M_carry;
-      int        _M_p;
-    };
-
-
-  /**
-   * @brief The Marsaglia-Zaman generator (floats version).
-   *
-   * @if maint
-   * @var _M_x     The state of the generator.  This is a ring buffer.
-   * @var _M_carry The carry.
-   * @var _M_p     Current index of x(i - r).
-   * @var _M_npows Precomputed negative powers of 2.   
-   * @endif
-   */
-  template<typename _RealType, int __w, int __s, int __r>
-    class subtract_with_carry_01
-    {
-    public:
-      /** The type of the generated random value. */
-      typedef _RealType result_type;
-      
-      // parameter values
-      static const int      word_size = __w;
-      static const int      long_lag  = __r;
-      static const int      short_lag = __s;
-
-      /**
-       * Constructs a default-initialized % subtract_with_carry_01 random
-       * number generator.
-       */
-      subtract_with_carry_01()
-      {
-	this->seed();
-	_M_initialize_npows();
-      }
-
-      /**
-       * Constructs an explicitly seeded % subtract_with_carry_01 random number
-       * generator.
-       */
-      explicit
-      subtract_with_carry_01(unsigned long __value)
-      {
-	this->seed(__value);
-	_M_initialize_npows();
-      }
-
-      /**
-       * Constructs a % subtract_with_carry_01 random number generator engine
-       * seeded from the generator function @p __g.
-       *
-       * @param __g The seed generator function.
-       */
-      template<class _Gen>
-        subtract_with_carry_01(_Gen& __g)
-        {
-	  this->seed(__g);
-	  _M_initialize_npows();	  
-	}
-
-      /**
-       * Seeds the initial state @f$ x_0 @f$ of the random number generator.
-       */
-      void
-      seed(unsigned long __value = 19780503);
-
-      /**
-       * Seeds the initial state @f$ x_0 @f$ of the % subtract_with_carry_01
-       * random number generator.
-       */
-      template<class _Gen>
-        void
-        seed(_Gen& __g)
-        { seed(__g, typename is_fundamental<_Gen>::type()); }
-
-      /**
-       * Gets the minimum value of the range of random floats
-       * returned by this generator.
-       */
-      result_type
-      min() const
-      { return 0.0; }
-
-      /**
-       * Gets the maximum value of the range of random floats
-       * returned by this generator.
-       */
-      result_type
-      max() const
-      { return 1.0; }
-
-      /**
-       * Gets the next random number in the sequence.
-       */
-      result_type
-      operator()();
-
-      /**
-       * Compares two % subtract_with_carry_01 random number generator objects
-       * of the same type for equality.
-       *
-       * @param __lhs A % subtract_with_carry_01 random number
-       *              generator object.
-       * @param __rhs Another % subtract_with_carry_01 random number generator
-       *              object.
-       *
-       * @returns true if the two objects are equal, false otherwise.
-       */
-      friend bool
-      operator==(const subtract_with_carry_01& __lhs,
-		 const subtract_with_carry_01& __rhs)
-      {
-	for (int __i = 0; __i < long_lag; ++__i)
-	  if (!std::equal(__lhs._M_x[__i], __lhs._M_x[__i] + __n,
-			  __rhs._M_x[__i]))
-	    return false;
-	return true;
-      }
-
-      /**
-       * Compares two % subtract_with_carry_01 random number generator objects
-       * of the same type for inequality.
-       *
-       * @param __lhs A % subtract_with_carry_01 random number
-       *              generator object.
-       *
-       * @param __rhs Another % subtract_with_carry_01 random number generator
-       *              object.
-       *
-       * @returns true if the two objects are not equal, false otherwise.
-       */
-      friend bool
-      operator!=(const subtract_with_carry_01& __lhs,
-		 const subtract_with_carry_01& __rhs)
-      { return !(__lhs == __rhs); }
-
-      /**
-       * Inserts the current state of a % subtract_with_carry_01 random number
-       * generator engine @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A % subtract_with_carry_01 random number generator engine.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _RealType1, int __w1, int __s1, int __r1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const subtract_with_carry_01<_RealType1, __w1, __s1,
-		   __r1>& __x);
-
-      /**
-       * Extracts the current state of a % subtract_with_carry_01 random number
-       * generator engine @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A % subtract_with_carry_01 random number generator engine.
-       *
-       * @returns The input stream with the state of @p __x extracted or in
-       * an error state.
-       */
-      template<typename _RealType1, int __w1, int __s1, int __r1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   subtract_with_carry_01<_RealType1, __w1, __s1, __r1>& __x);
-
-    private:
-      template<class _Gen>
-        void
-        seed(_Gen& __g, true_type)
-        { return seed(static_cast<unsigned long>(__g)); }
-
-      template<class _Gen>
-        void
-        seed(_Gen& __g, false_type);
-
-      void
-      _M_initialize_npows();
-
-      static const int __n = (__w + 31) / 32;
-
-      typedef __detail::_UInt32Type _UInt32Type;
-      _UInt32Type  _M_x[long_lag][__n];
-      _RealType    _M_npows[__n];
-      _UInt32Type  _M_carry;
-      int          _M_p;
-    };
-
-  typedef subtract_with_carry_01<float, 24, 10, 24>   ranlux_base_01;
-
-  // _GLIBCXX_RESOLVE_LIB_DEFECTS
-  // 508. Bad parameters for ranlux64_base_01.
-  typedef subtract_with_carry_01<double, 48, 5, 12> ranlux64_base_01;  
-
-
-  /**
-   * Produces random numbers from some base engine by discarding blocks of
-   * data.
-   *
-   * 0 <= @p __r <= @p __p
-   */
-  template<class _UniformRandomNumberGenerator, int __p, int __r>
-    class discard_block
-    {
-      // __glibcxx_class_requires(typename base_type::result_type,
-      //                          ArithmeticTypeConcept)
-
-    public:
-      /** The type of the underlying generator engine. */
-      typedef _UniformRandomNumberGenerator   base_type;
-      /** The type of the generated random value. */
-      typedef typename base_type::result_type result_type;
-
-      // parameter values
-      static const int block_size = __p;
-      static const int used_block = __r;
-
-      /**
-       * Constructs a default %discard_block engine.
-       *
-       * The underlying engine is default constructed as well.
-       */
-      discard_block()
-      : _M_n(0) { }
-
-      /**
-       * Copy constructs a %discard_block engine.
-       *
-       * Copies an existing base class random number geenerator.
-       * @param rng An existing (base class) engine object.
-       */
-      explicit
-      discard_block(const base_type& __rng)
-      : _M_b(__rng), _M_n(0) { }
-
-      /**
-       * Seed constructs a %discard_block engine.
-       *
-       * Constructs the underlying generator engine seeded with @p __s.
-       * @param __s A seed value for the base class engine.
-       */
-      explicit
-      discard_block(unsigned long __s)
-      : _M_b(__s), _M_n(0) { }
-
-      /**
-       * Generator construct a %discard_block engine.
-       *
-       * @param __g A seed generator function.
-       */
-      template<class _Gen>
-        discard_block(_Gen& __g)
-	: _M_b(__g), _M_n(0) { }
-
-      /**
-       * Reseeds the %discard_block object with the default seed for the
-       * underlying base class generator engine.
-       */
-      void seed()
-      {
-	_M_b.seed();
-	_M_n = 0;
-      }
-
-      /**
-       * Reseeds the %discard_block object with the given seed generator
-       * function.
-       * @param __g A seed generator function.
-       */
-      template<class _Gen>
-        void seed(_Gen& __g)
-        {
-	  _M_b.seed(__g);
-	  _M_n = 0;
-	}
-
-      /**
-       * Gets a const reference to the underlying generator engine object.
-       */
-      const base_type&
-      base() const
-      { return _M_b; }
-
-      /**
-       * Gets the minimum value in the generated random number range.
-       */
-      result_type
-      min() const
-      { return _M_b.min(); }
-
-      /**
-       * Gets the maximum value in the generated random number range.
-       */
-      result_type
-      max() const
-      { return _M_b.max(); }
-
-      /**
-       * Gets the next value in the generated random number sequence.
-       */
-      result_type
-      operator()();
-
-      /**
-       * Compares two %discard_block random number generator objects of
-       * the same type for equality.
-       *
-       * @param __lhs A %discard_block random number generator object.
-       * @param __rhs Another %discard_block random number generator
-       *              object.
-       *
-       * @returns true if the two objects are equal, false otherwise.
-       */
-      friend bool
-      operator==(const discard_block& __lhs, const discard_block& __rhs)
-      { return (__lhs._M_b == __rhs._M_b) && (__lhs._M_n == __rhs._M_n); }
-
-      /**
-       * Compares two %discard_block random number generator objects of
-       * the same type for inequality.
-       *
-       * @param __lhs A %discard_block random number generator object.
-       * @param __rhs Another %discard_block random number generator
-       *              object.
-       *
-       * @returns true if the two objects are not equal, false otherwise.
-       */
-      friend bool
-      operator!=(const discard_block& __lhs, const discard_block& __rhs)
-      { return !(__lhs == __rhs); }
-
-      /**
-       * Inserts the current state of a %discard_block random number
-       * generator engine @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %discard_block random number generator engine.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<class _UniformRandomNumberGenerator1, int __p1, int __r1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const discard_block<_UniformRandomNumberGenerator1,
-		   __p1, __r1>& __x);
-
-      /**
-       * Extracts the current state of a % subtract_with_carry random number
-       * generator engine @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A %discard_block random number generator engine.
-       *
-       * @returns The input stream with the state of @p __x extracted or in
-       * an error state.
-       */
-      template<class _UniformRandomNumberGenerator1, int __p1, int __r1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   discard_block<_UniformRandomNumberGenerator1,
-		   __p1, __r1>& __x);
-
-    private:
-      base_type _M_b;
-      int       _M_n;
-    };
-
-
-  /**
-   * James's luxury-level-3 integer adaptation of Luescher's generator.
-   */
-  typedef discard_block<
-    subtract_with_carry<unsigned long, (1UL << 24), 10, 24>,
-      223,
-      24
-      > ranlux3;
-
-  /**
-   * James's luxury-level-4 integer adaptation of Luescher's generator.
-   */
-  typedef discard_block<
-    subtract_with_carry<unsigned long, (1UL << 24), 10, 24>,
-      389,
-      24
-      > ranlux4;
-
-  typedef discard_block<
-    subtract_with_carry_01<float, 24, 10, 24>,
-      223,
-      24
-      > ranlux3_01;
-
-  typedef discard_block<
-    subtract_with_carry_01<float, 24, 10, 24>,
-      389,
-      24
-      > ranlux4_01;
-
-
-  /**
-   * A random number generator adaptor class that combines two random number
-   * generator engines into a single output sequence.
-   */
-  template<class _UniformRandomNumberGenerator1, int __s1,
-	   class _UniformRandomNumberGenerator2, int __s2>
-    class xor_combine
-    {
-      // __glibcxx_class_requires(typename _UniformRandomNumberGenerator1::
-      //                          result_type, ArithmeticTypeConcept)
-      // __glibcxx_class_requires(typename _UniformRandomNumberGenerator2::
-      //                          result_type, ArithmeticTypeConcept)
-
-    public:
-      /** The type of the the first underlying generator engine. */
-      typedef _UniformRandomNumberGenerator1   base1_type;
-      /** The type of the the second underlying generator engine. */
-      typedef _UniformRandomNumberGenerator2   base2_type;
-
-    private:
-      typedef typename base1_type::result_type _Result_type1;
-      typedef typename base2_type::result_type _Result_type2;
-
-    public:
-      /** The type of the generated random value. */
-      typedef typename __gnu_cxx::__conditional_type<(sizeof(_Result_type1)
-						      > sizeof(_Result_type2)),
-	_Result_type1, _Result_type2>::__type result_type;
-
-      // parameter values
-      static const int shift1 = __s1;
-      static const int shift2 = __s2;
-
-      // constructors and member function
-      xor_combine()
-      : _M_b1(), _M_b2()	
-      { _M_initialize_max(); }
-
-      xor_combine(const base1_type& __rng1, const base2_type& __rng2)
-      : _M_b1(__rng1), _M_b2(__rng2)
-      { _M_initialize_max(); }
-
-      xor_combine(unsigned long __s)
-      : _M_b1(__s), _M_b2(__s + 1)
-      { _M_initialize_max(); }
-
-      template<class _Gen>
-        xor_combine(_Gen& __g)
-	: _M_b1(__g), _M_b2(__g)
-        { _M_initialize_max(); }
-
-      void
-      seed()
-      {
-	_M_b1.seed();
-	_M_b2.seed();
-      }
-
-      template<class _Gen>
-        void
-        seed(_Gen& __g)
-        {
-	  _M_b1.seed(__g);
-	  _M_b2.seed(__g);
-	}
-
-      const base1_type&
-      base1() const
-      { return _M_b1; }
-
-      const base2_type&
-      base2() const
-      { return _M_b2; }
-
-      result_type
-      min() const
-      { return 0; }
-
-      result_type
-      max() const
-      { return _M_max; }
-
-      /**
-       * Gets the next random number in the sequence.
-       */
-      // NB: Not exactly the TR1 formula, per N2079 instead.
-      result_type
-      operator()()
-      {
-	return ((result_type(_M_b1() - _M_b1.min()) << shift1)
-		^ (result_type(_M_b2() - _M_b2.min()) << shift2));
-      }
-
-      /**
-       * Compares two %xor_combine random number generator objects of
-       * the same type for equality.
-       *
-       * @param __lhs A %xor_combine random number generator object.
-       * @param __rhs Another %xor_combine random number generator
-       *              object.
-       *
-       * @returns true if the two objects are equal, false otherwise.
-       */
-      friend bool
-      operator==(const xor_combine& __lhs, const xor_combine& __rhs)
-      {
-	return (__lhs.base1() == __rhs.base1())
-	        && (__lhs.base2() == __rhs.base2());
-      }
-
-      /**
-       * Compares two %xor_combine random number generator objects of
-       * the same type for inequality.
-       *
-       * @param __lhs A %xor_combine random number generator object.
-       * @param __rhs Another %xor_combine random number generator
-       *              object.
-       *
-       * @returns true if the two objects are not equal, false otherwise.
-       */
-      friend bool
-      operator!=(const xor_combine& __lhs, const xor_combine& __rhs)
-      { return !(__lhs == __rhs); }
-
-      /**
-       * Inserts the current state of a %xor_combine random number
-       * generator engine @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %xor_combine random number generator engine.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<class _UniformRandomNumberGenerator11, int __s11,
-	       class _UniformRandomNumberGenerator21, int __s21,
-	       typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const xor_combine<_UniformRandomNumberGenerator11, __s11,
-		   _UniformRandomNumberGenerator21, __s21>& __x);
-
-      /**
-       * Extracts the current state of a %xor_combine random number
-       * generator engine @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A %xor_combine random number generator engine.
-       *
-       * @returns The input stream with the state of @p __x extracted or in
-       * an error state.
-       */
-      template<class _UniformRandomNumberGenerator11, int __s11,
-	       class _UniformRandomNumberGenerator21, int __s21,
-	       typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   xor_combine<_UniformRandomNumberGenerator11, __s11,
-		   _UniformRandomNumberGenerator21, __s21>& __x);
-
-    private:
-      void
-      _M_initialize_max();
-
-      result_type
-      _M_initialize_max_aux(result_type, result_type, int);
-
-      base1_type  _M_b1;
-      base2_type  _M_b2;
-      result_type _M_max;
-    };
-
-
-  /**
-   * A standard interface to a platform-specific non-deterministic
-   * random number generator (if any are available).
-   */
-  class random_device
-  {
-  public:
-    // types
-    typedef unsigned int result_type;
-
-    // constructors, destructors and member functions
-
-#ifdef _GLIBCXX_USE_RANDOM_TR1
-
-    explicit
-    random_device(const std::string& __token = "/dev/urandom")
-    {
-      if ((__token != "/dev/urandom" && __token != "/dev/random")
-	  || !(_M_file = std::fopen(__token.c_str(), "rb")))
-	std::__throw_runtime_error(__N("random_device::"
-				       "random_device(const std::string&)"));
-    }
-
-    ~random_device()
-    { std::fclose(_M_file); }
-
-#else
-
-    explicit
-    random_device(const std::string& __token = "mt19937")
-    : _M_mt(_M_strtoul(__token)) { }
-
-  private:
-    static unsigned long
-    _M_strtoul(const std::string& __str)
-    {
-      unsigned long __ret = 5489UL;
-      if (__str != "mt19937")
-	{
-	  const char* __nptr = __str.c_str();
-	  char* __endptr;
-	  __ret = std::strtoul(__nptr, &__endptr, 0);
-	  if (*__nptr == '\0' || *__endptr != '\0')
-	    std::__throw_runtime_error(__N("random_device::_M_strtoul"
-					   "(const std::string&)"));
-	}
-      return __ret;
-    }
-
-  public:
-
-#endif
-
-    result_type
-    min() const
-    { return std::numeric_limits<result_type>::min(); }
-
-    result_type
-    max() const
-    { return std::numeric_limits<result_type>::max(); }
-
-    double
-    entropy() const
-    { return 0.0; }
-
-    result_type
-    operator()()
-    {
-#ifdef _GLIBCXX_USE_RANDOM_TR1
-      result_type __ret;
-      std::fread(reinterpret_cast<void*>(&__ret), sizeof(result_type),
-		 1, _M_file);
-      return __ret;
-#else
-      return _M_mt();
-#endif
-    }
-
-  private:
-    random_device(const random_device&);
-    void operator=(const random_device&);
-
-#ifdef _GLIBCXX_USE_RANDOM_TR1
-    FILE*        _M_file;
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/random>
 #else
-    mt19937      _M_mt;
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/random>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
 #endif
-  };
-
-  /* @} */ // group tr1_random_generators
-
-  /**
-   * @addtogroup tr1_random_distributions Random Number Distributions
-   * @ingroup tr1_random
-   * @{
-   */
-
-  /**
-   * @addtogroup tr1_random_distributions_discrete Discrete Distributions
-   * @ingroup tr1_random_distributions
-   * @{
-   */
-
-  /**
-   * @brief Uniform discrete distribution for random numbers.
-   * A discrete random distribution on the range @f$[min, max]@f$ with equal
-   * probability throughout the range.
-   */
-  template<typename _IntType = int>
-    class uniform_int
-    {
-      __glibcxx_class_requires(_IntType, _IntegerConcept)
- 
-    public:
-      /** The type of the parameters of the distribution. */
-      typedef _IntType input_type;
-      /** The type of the range of the distribution. */
-      typedef _IntType result_type;
-
-    public:
-      /**
-       * Constructs a uniform distribution object.
-       */
-      explicit
-      uniform_int(_IntType __min = 0, _IntType __max = 9)
-      : _M_min(__min), _M_max(__max)
-      {
-	_GLIBCXX_DEBUG_ASSERT(_M_min <= _M_max);
-      }
-
-      /**
-       * Gets the inclusive lower bound of the distribution range.
-       */
-      result_type
-      min() const
-      { return _M_min; }
-
-      /**
-       * Gets the inclusive upper bound of the distribution range.
-       */
-      result_type
-      max() const
-      { return _M_max; }
-
-      /**
-       * Resets the distribution state.
-       *
-       * Does nothing for the uniform integer distribution.
-       */
-      void
-      reset() { }
-
-      /**
-       * Gets a uniformly distributed random number in the range
-       * @f$(min, max)@f$.
-       */
-      template<typename _UniformRandomNumberGenerator>
-        result_type
-        operator()(_UniformRandomNumberGenerator& __urng)
-        {
-	  typedef typename _UniformRandomNumberGenerator::result_type
-	    _UResult_type;
-	  return _M_call(__urng, _M_min, _M_max,
-			 typename is_integral<_UResult_type>::type());
-	}
-
-      /**
-       * Gets a uniform random number in the range @f$[0, n)@f$.
-       *
-       * This function is aimed at use with std::random_shuffle.
-       */
-      template<typename _UniformRandomNumberGenerator>
-        result_type
-        operator()(_UniformRandomNumberGenerator& __urng, result_type __n)
-        {
-	  typedef typename _UniformRandomNumberGenerator::result_type
-	    _UResult_type;
-	  return _M_call(__urng, 0, __n - 1,
-			 typename is_integral<_UResult_type>::type());
-	}
-
-      /**
-       * Inserts a %uniform_int random number distribution @p __x into the
-       * output stream @p os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %uniform_int random number distribution.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _IntType1, typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const uniform_int<_IntType1>& __x);
-
-      /**
-       * Extracts a %unform_int random number distribution
-       * @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A %uniform_int random number generator engine.
-       *
-       * @returns The input stream with @p __x extracted or in an error state.
-       */
-      template<typename _IntType1, typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   uniform_int<_IntType1>& __x);
-
-    private:
-      template<typename _UniformRandomNumberGenerator>
-        result_type
-        _M_call(_UniformRandomNumberGenerator& __urng,
-		result_type __min, result_type __max, true_type)
-        { return result_type(__urng() % (__max - __min + 1)) + __min; }
-
-      template<typename _UniformRandomNumberGenerator>
-        result_type
-        _M_call(_UniformRandomNumberGenerator& __urng,
-		result_type __min, result_type __max, false_type)
-        {
-	  return result_type((__urng() - __urng.min())
-			     / (__urng.max() - __urng.min())
-			     * (__max - __min + 1)) + __min;
-	}
-
-      _IntType _M_min;
-      _IntType _M_max;
-    };
-
-
-  /**
-   * @brief A Bernoulli random number distribution.
-   *
-   * Generates a sequence of true and false values with likelihood @f$ p @f$
-   * that true will come up and @f$ (1 - p) @f$ that false will appear.
-   */
-  class bernoulli_distribution
-  {
-  public:
-    typedef int  input_type;
-    typedef bool result_type;
-
-  public:
-    /**
-     * Constructs a Bernoulli distribution with likelihood @p p.
-     *
-     * @param __p  [IN]  The likelihood of a true result being returned.  Must
-     * be in the interval @f$ [0, 1] @f$.
-     */
-    explicit
-    bernoulli_distribution(double __p = 0.5)
-    : _M_p(__p)
-    { 
-      _GLIBCXX_DEBUG_ASSERT((_M_p >= 0.0) && (_M_p <= 1.0));
-    }
-
-    /**
-     * Gets the @p p parameter of the distribution.
-     */
-    double
-    p() const
-    { return _M_p; }
-
-    /**
-     * Resets the distribution state.
-     *
-     * Does nothing for a bernoulli distribution.
-     */
-    void
-    reset() { }
-
-    /**
-     * Gets the next value in the Bernoullian sequence.
-     */
-    template<class _UniformRandomNumberGenerator>
-      result_type
-      operator()(_UniformRandomNumberGenerator& __urng)
-      {
-	if ((__urng() - __urng.min()) < _M_p * (__urng.max() - __urng.min()))
-	  return true;
-	return false;
-      }
-
-    /**
-     * Inserts a %bernoulli_distribution random number distribution
-     * @p __x into the output stream @p __os.
-     *
-     * @param __os An output stream.
-     * @param __x  A %bernoulli_distribution random number distribution.
-     *
-     * @returns The output stream with the state of @p __x inserted or in
-     * an error state.
-     */
-    template<typename _CharT, typename _Traits>
-      friend std::basic_ostream<_CharT, _Traits>&
-      operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		 const bernoulli_distribution& __x);
-
-    /**
-     * Extracts a %bernoulli_distribution random number distribution
-     * @p __x from the input stream @p __is.
-     *
-     * @param __is An input stream.
-     * @param __x  A %bernoulli_distribution random number generator engine.
-     *
-     * @returns The input stream with @p __x extracted or in an error state.
-     */
-    template<typename _CharT, typename _Traits>
-      friend std::basic_istream<_CharT, _Traits>&
-      operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		 bernoulli_distribution& __x)
-      { return __is >> __x._M_p; }
-
-  private:
-    double _M_p;
-  };
-
-
-  /**
-   * @brief A discrete geometric random number distribution.
-   *
-   * The formula for the geometric probability mass function is 
-   * @f$ p(i) = (1 - p)p^{i-1} @f$ where @f$ p @f$ is the parameter of the
-   * distribution.
-   */
-  template<typename _IntType = int, typename _RealType = double>
-    class geometric_distribution
-    {
-    public:
-      // types
-      typedef _RealType input_type;
-      typedef _IntType  result_type;
-
-      // constructors and member function
-      explicit
-      geometric_distribution(const _RealType& __p = _RealType(0.5))
-      : _M_p(__p)
-      {
-	_GLIBCXX_DEBUG_ASSERT((_M_p > 0.0) && (_M_p < 1.0));
-	_M_initialize();
-      }
-
-      /**
-       * Gets the distribution parameter @p p.
-       */
-      _RealType
-      p() const
-      { return _M_p; }
-
-      void
-      reset() { }
-
-      template<class _UniformRandomNumberGenerator>
-        result_type
-        operator()(_UniformRandomNumberGenerator& __urng);
-
-      /**
-       * Inserts a %geometric_distribution random number distribution
-       * @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %geometric_distribution random number distribution.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _IntType1, typename _RealType1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const geometric_distribution<_IntType1, _RealType1>& __x);
-
-      /**
-       * Extracts a %geometric_distribution random number distribution
-       * @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A %geometric_distribution random number generator engine.
-       *
-       * @returns The input stream with @p __x extracted or in an error state.
-       */
-      template<typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   geometric_distribution& __x)
-        {
-	  __is >> __x._M_p;
-	  __x._M_initialize();
-	  return __is;
-	}
-
-    private:
-      void
-      _M_initialize()
-      { _M_log_p = std::log(_M_p); }
-
-      _RealType _M_p;
-      _RealType _M_log_p;
-    };
-
-
-  template<typename _RealType>
-    class normal_distribution;
-
-  /**
-   * @brief A discrete Poisson random number distribution.
-   *
-   * The formula for the poisson probability mass function is 
-   * @f$ p(i) = \frac{mean^i}{i!} e^{-mean} @f$ where @f$ mean @f$ is the
-   * parameter of the distribution.
-   */
-  template<typename _IntType = int, typename _RealType = double>
-    class poisson_distribution
-    {
-    public:
-      // types
-      typedef _RealType input_type;
-      typedef _IntType  result_type;
-
-      // constructors and member function
-      explicit
-      poisson_distribution(const _RealType& __mean = _RealType(1))
-      : _M_mean(__mean), _M_nd()
-      {
-	_GLIBCXX_DEBUG_ASSERT(_M_mean > 0.0);
-	_M_initialize();
-      }
-
-      /**
-       * Gets the distribution parameter @p mean.
-       */
-      _RealType
-      mean() const
-      { return _M_mean; }
-
-      void
-      reset()
-      { _M_nd.reset(); }
-
-      template<class _UniformRandomNumberGenerator>
-        result_type
-        operator()(_UniformRandomNumberGenerator& __urng);
-
-      /**
-       * Inserts a %poisson_distribution random number distribution
-       * @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %poisson_distribution random number distribution.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _IntType1, typename _RealType1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const poisson_distribution<_IntType1, _RealType1>& __x);
-
-      /**
-       * Extracts a %poisson_distribution random number distribution
-       * @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A %poisson_distribution random number generator engine.
-       *
-       * @returns The input stream with @p __x extracted or in an error state.
-       */
-      template<typename _IntType1, typename _RealType1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   poisson_distribution<_IntType1, _RealType1>& __x);
-
-    private:
-      void
-      _M_initialize();
-
-      // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
-      normal_distribution<_RealType> _M_nd;
-
-      _RealType _M_mean;
-
-      // Hosts either log(mean) or the threshold of the simple method.
-      _RealType _M_lm_thr;
-#if _GLIBCXX_USE_C99_MATH_TR1
-      _RealType _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
-#endif
-    };
-
-
-  /**
-   * @brief A discrete binomial random number distribution.
-   *
-   * The formula for the binomial probability mass function is 
-   * @f$ p(i) = \binom{n}{i} p^i (1 - p)^{t - i} @f$ where @f$ t @f$
-   * and @f$ p @f$ are the parameters of the distribution.
-   */
-  template<typename _IntType = int, typename _RealType = double>
-    class binomial_distribution
-    {
-    public:
-      // types
-      typedef _RealType input_type;
-      typedef _IntType  result_type;
-
-      // constructors and member function
-      explicit
-      binomial_distribution(_IntType __t = 1,
-			    const _RealType& __p = _RealType(0.5))
-      : _M_t(__t), _M_p(__p), _M_nd()
-      {
-	_GLIBCXX_DEBUG_ASSERT((_M_t >= 0) && (_M_p >= 0.0) && (_M_p <= 1.0));
-	_M_initialize();
-      }
-
-      /**
-       * Gets the distribution @p t parameter.
-       */
-      _IntType
-      t() const
-      { return _M_t; }
-      
-      /**
-       * Gets the distribution @p p parameter.
-       */
-      _RealType
-      p() const
-      { return _M_p; }
-
-      void
-      reset()
-      { _M_nd.reset(); }
-
-      template<class _UniformRandomNumberGenerator>
-        result_type
-        operator()(_UniformRandomNumberGenerator& __urng);
-
-      /**
-       * Inserts a %binomial_distribution random number distribution
-       * @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %binomial_distribution random number distribution.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _IntType1, typename _RealType1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const binomial_distribution<_IntType1, _RealType1>& __x);
-
-      /**
-       * Extracts a %binomial_distribution random number distribution
-       * @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A %binomial_distribution random number generator engine.
-       *
-       * @returns The input stream with @p __x extracted or in an error state.
-       */
-      template<typename _IntType1, typename _RealType1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   binomial_distribution<_IntType1, _RealType1>& __x);
-
-    private:
-      void
-      _M_initialize();
-
-      template<class _UniformRandomNumberGenerator>
-        result_type
-        _M_waiting(_UniformRandomNumberGenerator& __urng, _IntType __t);
-
-      // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
-      normal_distribution<_RealType> _M_nd;
-
-      _RealType _M_q;
-#if _GLIBCXX_USE_C99_MATH_TR1
-      _RealType _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
-	        _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
-#endif
-      _RealType _M_p;
-      _IntType  _M_t;
-
-      bool      _M_easy;
-    };
-
-  /* @} */ // group tr1_random_distributions_discrete
-
-  /**
-   * @addtogroup tr1_random_distributions_continuous Continuous Distributions
-   * @ingroup tr1_random_distributions
-   * @{
-   */
-
-  /**
-   * @brief Uniform continuous distribution for random numbers.
-   *
-   * A continuous random distribution on the range [min, max) with equal
-   * probability throughout the range.  The URNG should be real-valued and
-   * deliver number in the range [0, 1).
-   */
-  template<typename _RealType = double>
-    class uniform_real
-    {
-    public:
-      // types
-      typedef _RealType input_type;
-      typedef _RealType result_type;
-
-    public:
-      /**
-       * Constructs a uniform_real object.
-       *
-       * @param __min [IN]  The lower bound of the distribution.
-       * @param __max [IN]  The upper bound of the distribution.
-       */
-      explicit
-      uniform_real(_RealType __min = _RealType(0),
-		   _RealType __max = _RealType(1))
-      : _M_min(__min), _M_max(__max)
-      {
-	_GLIBCXX_DEBUG_ASSERT(_M_min <= _M_max);
-      }
-
-      result_type
-      min() const
-      { return _M_min; }
-
-      result_type
-      max() const
-      { return _M_max; }
-
-      void
-      reset() { }
-
-      template<class _UniformRandomNumberGenerator>
-        result_type
-        operator()(_UniformRandomNumberGenerator& __urng)
-        { return (__urng() * (_M_max - _M_min)) + _M_min; }
-
-      /**
-       * Inserts a %uniform_real random number distribution @p __x into the
-       * output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %uniform_real random number distribution.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _RealType1, typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const uniform_real<_RealType1>& __x);
-
-      /**
-       * Extracts a %unform_real random number distribution
-       * @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A %uniform_real random number generator engine.
-       *
-       * @returns The input stream with @p __x extracted or in an error state.
-       */
-      template<typename _RealType1, typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   uniform_real<_RealType1>& __x);
-
-    private:
-      _RealType _M_min;
-      _RealType _M_max;
-    };
-
-
-  /**
-   * @brief An exponential continuous distribution for random numbers.
-   *
-   * The formula for the exponential probability mass function is 
-   * @f$ p(x) = \lambda e^{-\lambda x} @f$.
-   *
-   * <table border=1 cellpadding=10 cellspacing=0>
-   * <caption align=top>Distribution Statistics</caption>
-   * <tr><td>Mean</td><td>@f$ \frac{1}{\lambda} @f$</td></tr>
-   * <tr><td>Median</td><td>@f$ \frac{\ln 2}{\lambda} @f$</td></tr>
-   * <tr><td>Mode</td><td>@f$ zero @f$</td></tr>
-   * <tr><td>Range</td><td>@f$[0, \infty]@f$</td></tr>
-   * <tr><td>Standard Deviation</td><td>@f$ \frac{1}{\lambda} @f$</td></tr>
-   * </table>
-   */
-  template<typename _RealType = double>
-    class exponential_distribution
-    {
-    public:
-      // types
-      typedef _RealType input_type;
-      typedef _RealType result_type;
-
-    public:
-      /**
-       * Constructs an exponential distribution with inverse scale parameter
-       * @f$ \lambda @f$.
-       */
-      explicit
-      exponential_distribution(const result_type& __lambda = result_type(1))
-      : _M_lambda(__lambda)
-      { 
-	_GLIBCXX_DEBUG_ASSERT(_M_lambda > 0);
-      }
-
-      /**
-       * Gets the inverse scale parameter of the distribution.
-       */
-      _RealType
-      lambda() const
-      { return _M_lambda; }
-
-      /**
-       * Resets the distribution.
-       *
-       * Has no effect on exponential distributions.
-       */
-      void
-      reset() { }
-
-      template<class _UniformRandomNumberGenerator>
-        result_type
-        operator()(_UniformRandomNumberGenerator& __urng)
-        { return -std::log(__urng()) / _M_lambda; }
-
-      /**
-       * Inserts a %exponential_distribution random number distribution
-       * @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %exponential_distribution random number distribution.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _RealType1, typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const exponential_distribution<_RealType1>& __x);
-
-      /**
-       * Extracts a %exponential_distribution random number distribution
-       * @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x A %exponential_distribution random number
-       *            generator engine.
-       *
-       * @returns The input stream with @p __x extracted or in an error state.
-       */
-      template<typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   exponential_distribution& __x)
-        { return __is >> __x._M_lambda; }
-
-    private:
-      result_type _M_lambda;
-    };
-
-
-  /**
-   * @brief A normal continuous distribution for random numbers.
-   *
-   * The formula for the normal probability mass function is 
-   * @f$ p(x) = \frac{1}{\sigma \sqrt{2 \pi}} 
-   *            e^{- \frac{{x - mean}^ {2}}{2 \sigma ^ {2}} } @f$.
-   */
-  template<typename _RealType = double>
-    class normal_distribution
-    {
-    public:
-      // types
-      typedef _RealType input_type;
-      typedef _RealType result_type;
-
-    public:
-      /**
-       * Constructs a normal distribution with parameters @f$ mean @f$ and
-       * @f$ \sigma @f$.
-       */
-      explicit
-      normal_distribution(const result_type& __mean = result_type(0),
-			  const result_type& __sigma = result_type(1))
-      : _M_mean(__mean), _M_sigma(__sigma), _M_saved_available(false)
-      { 
-	_GLIBCXX_DEBUG_ASSERT(_M_sigma > 0);
-      }
-
-      /**
-       * Gets the mean of the distribution.
-       */
-      _RealType
-      mean() const
-      { return _M_mean; }
-
-      /**
-       * Gets the @f$ \sigma @f$ of the distribution.
-       */
-      _RealType
-      sigma() const
-      { return _M_sigma; }
-
-      /**
-       * Resets the distribution.
-       */
-      void
-      reset()
-      { _M_saved_available = false; }
-
-      template<class _UniformRandomNumberGenerator>
-        result_type
-        operator()(_UniformRandomNumberGenerator& __urng);
-
-      /**
-       * Inserts a %normal_distribution random number distribution
-       * @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %normal_distribution random number distribution.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _RealType1, typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const normal_distribution<_RealType1>& __x);
-
-      /**
-       * Extracts a %normal_distribution random number distribution
-       * @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A %normal_distribution random number generator engine.
-       *
-       * @returns The input stream with @p __x extracted or in an error state.
-       */
-      template<typename _RealType1, typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   normal_distribution<_RealType1>& __x);
-
-    private:
-      result_type _M_mean;
-      result_type _M_sigma;
-      result_type _M_saved;
-      bool        _M_saved_available;     
-    };
-
-
-  /**
-   * @brief A gamma continuous distribution for random numbers.
-   *
-   * The formula for the gamma probability mass function is 
-   * @f$ p(x) = \frac{1}{\Gamma(\alpha)} x^{\alpha - 1} e^{-x} @f$.
-   */
-  template<typename _RealType = double>
-    class gamma_distribution
-    {
-    public:
-      // types
-      typedef _RealType input_type;
-      typedef _RealType result_type;
-
-    public:
-      /**
-       * Constructs a gamma distribution with parameters @f$ \alpha @f$.
-       */
-      explicit
-      gamma_distribution(const result_type& __alpha_val = result_type(1))
-      : _M_alpha(__alpha_val)
-      { 
-	_GLIBCXX_DEBUG_ASSERT(_M_alpha > 0);
-	_M_initialize();
-      }
-
-      /**
-       * Gets the @f$ \alpha @f$ of the distribution.
-       */
-      _RealType
-      alpha() const
-      { return _M_alpha; }
-
-      /**
-       * Resets the distribution.
-       */
-      void
-      reset() { }
-
-      template<class _UniformRandomNumberGenerator>
-        result_type
-        operator()(_UniformRandomNumberGenerator& __urng);
-
-      /**
-       * Inserts a %gamma_distribution random number distribution
-       * @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %gamma_distribution random number distribution.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _RealType1, typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const gamma_distribution<_RealType1>& __x);
-
-      /**
-       * Extracts a %gamma_distribution random number distribution
-       * @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A %gamma_distribution random number generator engine.
-       *
-       * @returns The input stream with @p __x extracted or in an error state.
-       */
-      template<typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   gamma_distribution& __x)
-        {
-	  __is >> __x._M_alpha;
-	  __x._M_initialize();
-	  return __is;
-	}
-
-    private:
-      void
-      _M_initialize();
-
-      result_type _M_alpha;
-
-      // Hosts either lambda of GB or d of modified Vaduva's.
-      result_type _M_l_d;
-    };
-
-  /* @} */ // group tr1_random_distributions_continuous
-  /* @} */ // group tr1_random_distributions
-  /* @} */ // group tr1_random
-
-_GLIBCXX_END_NAMESPACE
-}
-
-#include <tr1/random.tcc>
 
-#endif // _TR1_RANDOM
+#endif // _GLIBCXX_TR1_RANDOM
diff --git a/libstdc++-v3/include/tr1/regex b/libstdc++-v3/include/tr1/regex
index 3b8f03f..0282977 100644
--- a/libstdc++-v3/include/tr1/regex
+++ b/libstdc++-v3/include/tr1/regex
@@ -33,2397 +33,36 @@
  * This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_REGEX
-#define _TR1_REGEX 1
+#ifndef _GLIBCXX_TR1_REGEX
+#define _GLIBCXX_TR1_REGEX 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
 
-#include <bits/c++config.h>
 #include <algorithm>
 #include <bitset>
 #include <iterator>
 #include <locale>
 #include <stdexcept>
 #include <string>
-#include <utility>
 #include <vector>
+#include <utility>
 
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-/**
- * @addtogroup tr1_regex Regular Expressions
- * A facility for performing regular expression pattern matching.
- * @{
- */
-
-namespace regex_constants
-{
-  // [7.5.1] Bitmask Type syntax_option_type
-  enum __syntax_option
-    {
-      _S_icase,
-      _S_nosubs,
-      _S_optimize,
-      _S_collate,
-      _S_ECMAScript,
-      _S_basic,
-      _S_extended,
-      _S_awk,
-      _S_grep,
-      _S_egrep,
-      _S_syntax_last
-    };
-
-  /**
-   * @brief This is a bitmask type indicating how to interpret the regex.
-   *
-   * The @c syntax_option_type is implementation defined but it is valid to
-   * perform bitwise operations on these values and expect the right thing to
-   * happen.
-   *
-   * A valid value of type syntax_option_type shall have exactly one of the
-   * elements @c ECMAScript, @c basic, @c extended, @c awk, @c grep, @c egrep
-   * set.
-   */
-  typedef unsigned int syntax_option_type;
-
-  /// Specifies that the matching of regular expressions against a character
-  /// sequence shall be performed without regard to case.
-  static const syntax_option_type icase      = 1 << _S_icase;
-
-  /// Specifies that when a regular expression is matched against a character
-  /// container sequence, no sub-expression matches are to be stored in the
-  /// supplied match_results structure.
-  static const syntax_option_type nosubs     = 1 << _S_nosubs;
-
-  /// Specifies that the regular expression engine should pay more attention to
-  /// the speed with which regular expressions are matched, and less to the
-  /// speed with which regular expression objects are constructed. Otherwise
-  /// it has no detectable effect on the program output.
-  static const syntax_option_type optimize   = 1 << _S_optimize;
-
-  /// Specifies that character ranges of the form [a-b] should be locale
-  /// sensitive.
-  static const syntax_option_type collate    = 1 << _S_collate;
-
-  /// Specifies that the grammar recognized by the regular expression engine is
-  /// that used by ECMAScript in ECMA-262 [Ecma International, ECMAScript
-  /// Language Specification, Standard Ecma-262, third edition, 1999], as
-  /// modified in tr1 section [7.13].  This grammar is similar to that defined
-  /// in the PERL scripting language but extended with elements found in the
-  /// POSIX regular expression grammar.
-  static const syntax_option_type ECMAScript = 1 << _S_ECMAScript;
-
-  /// Specifies that the grammar recognized by the regular expression engine is
-  /// that used by POSIX basic regular expressions in IEEE Std 1003.1-2001,
-  /// Portable Operating System Interface (POSIX), Base Definitions and
-  /// Headers, Section 9, Regular Expressions [IEEE, Information Technology --
-  /// Portable Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
-  static const syntax_option_type basic      = 1 << _S_basic;
-
-  /// Specifies that the grammar recognized by the regular expression engine is
-  /// that used by POSIX extended regular expressions in IEEE Std 1003.1-2001,
-  /// Portable Operating System Interface (POSIX), Base Definitions and Headers,
-  /// Section 9, Regular Expressions.
-  static const syntax_option_type extended   = 1 << _S_extended;
-
-  /// Specifies that the grammar recognized by the regular expression engine is
-  /// that used by POSIX utility awk in IEEE Std 1003.1-2001.  This option is
-  /// identical to syntax_option_type extended, except that C-style escape
-  /// sequences are supported.  These sequences are, explicitly, '\\', '\a',
-  /// '\b', '\f', '\n', '\r', '\t' , '\v', '\"', '\\', and '\ddd' (where ddd is
-  /// one, two, or three octal digits).  
-  static const syntax_option_type awk        = 1 << _S_awk;
-
-  /// Specifies that the grammar recognized by the regular expression engine is
-  /// that used by POSIX utility grep in IEEE Std 1003.1-2001.  This option is
-  /// identical to syntax_option_type basic, except that newlines are treated
-  /// as whitespace.
-  static const syntax_option_type grep       = 1 << _S_grep;
-
-  /// Specifies that the grammar recognized by the regular expression engine is
-  /// that used by POSIX utility grep when given the -E option in
-  /// IEEE Std 1003.1-2001.  This option is identical to syntax_option_type 
-  /// extended, except that newlines are treated as whitespace.
-  static const syntax_option_type egrep      = 1 << _S_egrep;
-
-
-  // [7.5.2] Bitmask Type match_flag_type
-  enum __match_flag
-    {
-      _S_not_bol,
-      _S_not_eol,
-      _S_not_bow,
-      _S_not_eow,
-      _S_any,
-      _S_not_null,
-      _S_continuous,
-      _S_prev_avail,
-      _S_sed,
-      _S_no_copy,
-      _S_first_only,
-      _S_match_flag_last
-    };
-
-  /**
-   * @brief This is a bitmask type indicating regex matching rules.
-   *
-   * Matching a regular expression against a sequence of characters [first,
-   * last) proceeds according to the rules of the grammar specified for the
-   * regular expression object, modified according to the effects listed
-   * below for any bitmask elements set.
-   *
-   * The @c match_flag_type is implementation defined but it is valid to
-   * perform bitwise operations on these values and expect the right thing to
-   * happen.
-   */
-  typedef std::bitset<_S_match_flag_last> match_flag_type;
-
-  static const match_flag_type match_default     = 0;
-
-  /// The first character in the sequence [first, last) is treated as though it
-  /// is not at the beginning of a line, so the character "^" in the regular
-  /// expression shall not match [first, first).
-  static const match_flag_type match_not_bol     = 1 << _S_not_bol;
-
-  /// The last character in the sequence [first, last) is treated as though it
-  /// is not at the end of a line, so the character "$" in the regular
-  /// expression shall not match [last, last).
-  static const match_flag_type match_not_eol     = 1 << _S_not_eol;
-   
-  /// The expression "\b" is not matched against the sub-sequence
-  /// [first,first).
-  static const match_flag_type match_not_bow     = 1 << _S_not_bow;
-   
-  /// The expression "\b" should not be matched against the sub-sequence
-  /// [last,last).
-  static const match_flag_type match_not_eow     = 1 << _S_not_eow;
-   
-  /// If more than one match is possible then any match is an acceptable
-  /// result.
-  static const match_flag_type match_any         = 1 << _S_any;
-   
-  /// The expression does not match an empty sequence.
-  static const match_flag_type match_not_null    = 1 << _S_not_null;
-   
-  /// The expression only matchs a sub-sequence that begins at first .
-  static const match_flag_type match_continuous  = 1 << _S_continuous;
-   
-  /// --first is a valid iterator position.  When this flag is set then the
-  /// flags match_not_bol and match_not_bow are ignored by the regular
-  /// expression algorithms 7.11 and iterators 7.12.
-  static const match_flag_type match_prev_avail  = 1 << _S_prev_avail;
-
-  /// When a regular expression match is to be replaced by a new string, the
-  /// new string is constructed using the rules used by the ECMAScript replace
-  /// function in ECMA- 262 [Ecma International, ECMAScript Language
-  /// Specification, Standard Ecma-262, third edition, 1999], part 15.5.4.11
-  /// String.prototype.replace. In addition, during search and replace
-  /// operations all non-overlapping occurrences of the regular expression
-  /// are located and replaced, and sections of the input that did not match
-  /// the expression are copied unchanged to the output string.
-  ///
-  /// Format strings (from ECMA-262 [15.5.4.11]):
-  /// $$  $
-  /// $&  The matched substring.
-  /// $`  The portion of <em>string</em> that preceeds the matched substring.
-  /// $'  The portion of <em>string</em> that follows the matched substring.
-  /// $n  The nth capture, where n is in [1,9] and $n is not followed by a
-  ///     decimal digit.  If n <= m and the nth capture is undefined, use the
-  ///     empty string
-  ///     instead. If n > m, the result is implementation-defined.
-  /// $nn The nnth capture, where nn is a two-digit decimal number on [01, 99].
-  ///     If nn <= m and the nth capture is undefined, use the empty string
-  ///     instead. If nn > m, the result is implementation-defined.
-  ///
-  static const match_flag_type format_default    = 0;
-
-  /// When a regular expression match is to be replaced by a new string, the
-  /// new string is constructed using the rules used by the POSIX sed utility
-  /// in IEEE Std 1003.1- 2001 [IEEE, Information Technology -- Portable
-  /// Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
-  static const match_flag_type format_sed        = 1 << _S_sed;
-
-  /// During a search and replace operation, sections of the character
-  /// container sequence being searched that do not match the regular
-  /// expression shall not be copied to the output string.
-  static const match_flag_type format_no_copy    = 1 << _S_no_copy;
-
-  /// When specified during a search and replace operation, only the first
-  /// occurrence of the regular expression shall be replaced.
-  static const match_flag_type format_first_only = 1 << _S_first_only;
-
-
-  // [7.5.3] implementation-defined error type
-  enum error_type
-    {
-      _S_error_collate,
-      _S_error_ctype,
-      _S_error_escape,
-      _S_error_backref,
-      _S_error_brack,
-      _S_error_paren,
-      _S_error_brace,
-      _S_error_badbrace,
-      _S_error_range,
-      _S_error_space,
-      _S_error_badrepeat,
-      _S_error_complexity,
-      _S_error_stack,
-      _S_error_last
-    };
-
-  /// The expression contained an invalid collating element name.
-  static const error_type error_collate(_S_error_collate);
-
-  /// The expression contained an invalid character class name.
-  static const error_type error_ctype(_S_error_ctype);
-
-  /// The expression contained an invalid escaped character, or a trailing
-  /// escape.
-  static const error_type error_escape(_S_error_escape);
-
-  /// The expression contained an invalid back reference.
-  static const error_type error_backref(_S_error_backref);
-
-  /// The expression contained mismatched [ and ].
-  static const error_type error_brack(_S_error_brack);
-
-  /// The expression contained mismatched ( and ).
-  static const error_type error_paren(_S_error_paren);
-
-  /// The expression contained mismatched { and }
-  static const error_type error_brace(_S_error_brace);
-
-  /// The expression contained an invalid range in a {} expression.
-  static const error_type error_badbrace(_S_error_badbrace);
-
-  /// The expression contained an invalid character range,
-  /// such as [b-a] in most encodings.
-  static const error_type error_range(_S_error_range);
-
-  /// There was insufficient memory to convert the expression into a
-  /// finite state machine.
-  static const error_type error_space(_S_error_space);
-
-  /// One of *?+{ was not preceded by a valid regular expression.
-  static const error_type error_badrepeat(_S_error_badrepeat);
-
-  /// The complexity of an attempted match against a regular expression
-  /// exceeded a pre-set level.
-  static const error_type error_complexity(_S_error_complexity);
-
-  /// There was insufficient memory to determine whether the
-  /// regular expression could match the specified character sequence.
-  static const error_type error_stack(_S_error_stack);
-}
-
-
-  // [7.8] Class regex_error
-  /**
-   * Defines the type of objects thrown as exceptions to report errors from the
-   * regular expression library.
-   */
-  class regex_error
-  : public std::runtime_error
-  {
-  public:
-    /**
-     * @brief constructs a regex_error object.
-     *
-     * @param ecode the regex error code.
-     */
-    explicit
-    regex_error(regex_constants::error_type __ecode)
-    : std::runtime_error("regex_error"), _M_code(__ecode)
-    { }
-
-    /**
-     * @brief gets the regex error code.
-     *
-     * @returns the regex error code.
-     */
-    regex_constants::error_type
-    code() const
-    { return _M_code; }
-
-  protected:
-    regex_constants::error_type _M_code;
-  };
-
-
-  // [7.7] Class regex_traits
-  /**
-   * A regular expression traits class that satisfies the requirements of tr1
-   * section [7.2].
-   *
-   * The class %regex is parameterized around a set of related types and
-   * functions used to complete the definition of its semantics.  This class
-   * satisfies the requirements of such a traits class.
-   */
-  template<typename _Ch_type>
-    struct regex_traits
-    {
-    public:
-      typedef _Ch_type                     char_type;
-      typedef std::basic_string<char_type> string_type;
-      typedef std::locale                  locale_type;
-      typedef std::ctype_base::mask        char_class_type;
-
-    public:
-      /**
-       * @brief Constructs a default traits object.
-       */
-      regex_traits()
-      { }
-      
-      /**
-       * @brief Gives the length of a C-style string starting at @p __p.
-       *
-       * @param __p a pointer to the start of a character sequence.
-       *
-       * @returns the number of characters between @p *__p and the first
-       * default-initialized value of type @p char_type.  In other words, uses
-       * the C-string algorithm for determiining the length of a sequence of
-       * characters.
-       */
-      static std::size_t
-      length(const char_type* __p)
-      { return string_type::traits_type::length(__p); }
-
-      /**
-       * @brief Performs the identity translation.
-       *
-       * @param c A character to the locale-specific character set.
-       *
-       * @returns c.
-       */
-      char_type
-      translate(char_type __c) const
-      { return __c; }
-      
-      /**
-       * @brief Translates a character into a case-insensitive equivalent.
-       *
-       * @param c A character to the locale-specific character set.
-       *
-       * @returns the locale-specific lower-case equivalent of c.
-       * @throws std::bad_cast if the imbued locale does not support the ctype
-       *         facet.
-       */
-      char_type
-      translate_nocase(char_type __c) const
-      {
-	using std::ctype;
-	using std::use_facet;
-	return use_facet<ctype<char_type> >(_M_locale).tolower(__c);
-      }
-      
-      /**
-       * @brief Gets a sort key for a character sequence.
-       *
-       * @param first beginning of the character sequence.
-       * @param last  one-past-the-end of the character sequence.
-       *
-       * Returns a sort key for the character sequence designated by the
-       * iterator range [F1, F2) such that if the character sequence [G1, G2)
-       * sorts before the character sequence [H1, H2) then
-       * v.transform(G1, G2) < v.transform(H1, H2).
-       *
-       * What this really does is provide a more efficient way to compare a
-       * string to multiple other strings in locales with fancy collation
-       * rules and equivalence classes.
-       *
-       * @returns a locale-specific sort key equivalent to the input range.
-       *
-       * @throws std::bad_cast if the current locale does not have a collate
-       *         facet.
-       */
-      template<typename _Fwd_iter>
-        string_type
-        transform(_Fwd_iter __first, _Fwd_iter __last) const
-        {
-	  using std::collate;
-	  using std::use_facet;
-	  const collate<_Ch_type>& __c(use_facet<
-				       collate<_Ch_type> >(_M_locale));
-	  string_type __s(__first, __last);
-	  return __c.transform(__s.data(), __s.data() + __s.size());
-	}
-
-      /**
-       * @brief Dunno.
-       *
-       * @param first beginning of the character sequence.
-       * @param last  one-past-the-end of the character sequence.
-       *
-       * Effects: if typeid(use_facet<collate<_Ch_type> >) ==
-       * typeid(collate_byname<_Ch_type>) and the form of the sort key
-       * returned by collate_byname<_Ch_type>::transform(first, last) is known
-       * and can be converted into a primary sort key then returns that key,
-       * otherwise returns an empty string. WTF??
-       *
-       * @todo Implement this function.
-       */
-      template<typename _Fwd_iter>
-        string_type
-        transform_primary(_Fwd_iter __first, _Fwd_iter __last) const
-        { return string_type(); }
-
-      /**
-       * @breief Gets a collation element by name.
-       *
-       * @param first beginning of the collation element name.
-       * @param last  one-past-the-end of the collation element name.
-       * 
-       * @returns a sequence of one or more characters that represents the
-       * collating element consisting of the character sequence designated by
-       * the iterator range [first, last). Returns an empty string if the
-       * character sequence is not a valid collating element.
-       *
-       * @todo Implement this function.
-       */
-      template<typename _Fwd_iter>
-        string_type
-        lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const
-        { return string_type(); }
-
-      /**
-       * @brief Maps one or mire characters to a named character
-       *        classification.
-       *
-       * @param first beginning of the character sequence.
-       * @param last  one-past-the-end of the character sequence.
-       *
-       * @returns an unspecified value that represents the character
-       * classification named by the character sequence designated by the
-       * iterator range [first, last). The value returned shall be independent
-       * of the case of the characters in the character sequence. If the name
-       * is not recognized then returns a value that compares equal to 0.
-       *
-       * At least the following names (or their wide-character equivalent) are
-       * supported.
-       * - d
-       * - w
-       * - s
-       * - alnum
-       * - alpha
-       * - blank
-       * - cntrl
-       * - digit
-       * - graph
-       * - lower
-       * - print
-       * - punct
-       * - space
-       * - upper
-       * - xdigit
-       *
-       * @todo Implement this function.
-       */
-      template<typename _Fwd_iter>
-        char_class_type
-        lookup_classname(_Fwd_iter __first, _Fwd_iter __last) const
-        { return 0; }
-
-      /**
-       * @brief Determines if @p c is a member of an identified class.
-       *
-       * @param c a character.
-       * @param f a class type (as returned from lookup_classname).
-       *
-       * @returns true if the character @p c is a member of the classification
-       * represented by @p f, false otherwise.
-       *
-       * @throws std::bad_cast if the current locale does not have a ctype
-       *         facet.
-       */
-      bool
-      isctype(_Ch_type __c, char_class_type __f) const
-      {
-	using std::ctype;
-	using std::use_facet;
-	const ctype<_Ch_type>& __ctype(use_facet<
-				       ctype<_Ch_type> >(_M_locale));
-	
-	if (__ctype.is(__c, __f))
-	  return true;
-	
-	// special case of underscore in [[:w:]]
-	if (__c == __ctype.widen('_'))
-	  {
-	    const char* const __wb[] = "w";
-	    char_class_type __wt = this->lookup_classname(__wb,
-							  __wb + sizeof(__wb));
-	    if (__f | __wt)
-	      return true;
-	  }
-      
-	// special case of [[:space:]] in [[:blank:]]
-	if (__c == __ctype.isspace(__c))
-	  {
-	    const char* const __bb[] = "blank";
-	    char_class_type __bt = this->lookup_classname(__bb,
-							  __bb + sizeof(__bb));
-	    if (__f | __bt)
-	      return true;
-	  }
-	
-	return false;
-      }
-
-      /**
-       * @brief Converts a digit to an int.
-       *
-       * @param ch    a character representing a digit.
-       * @param radix the radix if the numeric conversion (limited to 8, 10,
-       *              or 16).
-       * 
-       * @returns the value represented by the digit ch in base radix if the
-       * character ch is a valid digit in base radix; otherwise returns -1.
-       *
-       * @todo Implement this function.
-       */
-      int
-      value(_Ch_type __ch, int __radix) const;
-      
-      /**
-       * @brief Imbues the regex_traits object with a copy of a new locale.
-       *
-       * @param loc A locale.
-       *
-       * @returns a copy of the previous locale in use by the regex_traits
-       *          object.
-       *
-       * @note Calling imbue with a different locale than the one currently in
-       *       use invalidates all cached data held by *this.
-       */
-      locale_type
-      imbue(locale_type __loc)
-      {
-	std::swap(_M_locale, __loc);
-	return __loc;
-      }
-      
-      /**
-       * @brief Gets a copy of the current locale in use by the regex_traits
-       * object.
-       */
-      locale_type
-      getloc() const
-      { return _M_locale; }
-      
-    protected:
-      locale_type _M_locale;
-    };
-
-
-  // [7.8] Class basic_regex
-  /**
-   * Objects of specializations of this class represent regular expressions
-   * constructed from sequences of character type @p _Ch_type.
-   *
-   * Storage for the regular expression is allocated and deallocated as
-   * necessary by the member functions of this class.
-   */
-  template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type> >
-    class basic_regex
-    {
-    public:
-      // types:
-      typedef _Ch_type                              value_type;
-      typedef regex_constants::syntax_option_type flag_type;
-      typedef typename _Rx_traits::locale_type  locale_type;
-      typedef typename _Rx_traits::string_type  string_type;
-
-      // [7.8.1] constants
-      static const regex_constants::syntax_option_type icase
-        = regex_constants::icase;
-      static const regex_constants::syntax_option_type nosubs
-        = regex_constants::nosubs;
-      static const regex_constants::syntax_option_type optimize
-        = regex_constants::optimize;
-      static const regex_constants::syntax_option_type collate
-        = regex_constants::collate;
-      static const regex_constants::syntax_option_type ECMAScript
-        = regex_constants::ECMAScript;
-      static const regex_constants::syntax_option_type basic
-        = regex_constants::basic;
-      static const regex_constants::syntax_option_type extended
-        = regex_constants::extended;
-      static const regex_constants::syntax_option_type awk
-        = regex_constants::awk;
-      static const regex_constants::syntax_option_type grep
-        = regex_constants::grep;
-      static const regex_constants::syntax_option_type egrep
-        = regex_constants::egrep;
-
-      // [7.8.2] construct/copy/destroy
-      /**
-       * Constructs a basic regular expression that does not match any
-       * character sequence.
-       */
-      basic_regex()
-      : _M_flags(regex_constants::ECMAScript), _M_pattern(), _M_mark_count(0)
-      { _M_compile(); }
-
-      /**
-       * @brief Constructs a basic regular expression from the sequence
-       * [p, p + char_traits<_Ch_type>::length(p)) interpreted according to the
-       * flags in @p f.
-       *
-       * @param p A pointer to the start of a C-style null-terminated string
-       *          containing a regular expression.
-       * @param f Flags indicating the syntax rules and options.
-       *
-       * @throws regex_error if @p p is not a valid regular expression.
-       */
-      explicit
-      basic_regex(const _Ch_type* __p,
-		  flag_type __f = regex_constants::ECMAScript)
-      : _M_flags(__f), _M_pattern(__p), _M_mark_count(0)
-      { _M_compile(); }
-
-      /**
-       * @brief Constructs a basic regular expression from the sequence
-       * [p, p + len) interpreted according to the flags in @p f.
-       *
-       * @param p   A pointer to the start of a string containing a regular
-       *            expression.
-       * @param len The length of the string containing the regular expression.
-       * @param f   Flags indicating the syntax rules and options.
-       *
-       * @throws regex_error if @p p is not a valid regular expression.
-       */
-      basic_regex(const _Ch_type* __p, std::size_t __len, flag_type __f)
-      : _M_flags(__f) , _M_pattern(__p, __len), _M_mark_count(0)
-      { _M_compile(); }
-
-      /**
-       * @brief Copy-contructs a basic regular expression.
-       *
-       * @param rhs A @p regex object.
-     */
-      basic_regex(const basic_regex& __rhs)
-      : _M_flags(__rhs._M_flags), _M_pattern(__rhs._M_pattern),
-	_M_mark_count(__rhs._M_mark_count)
-      { _M_compile(); }
-
-      /**
-       * @brief Constructs a basic regular expression from the string
-       * @p interpreted according to the flags in @p f.
-       *
-       * @param p A string containing a regular expression.
-       * @param f Flags indicating the syntax rules and options.
-       *
-       * @throws regex_error if @p p is not a valid regular expression.
-       */
-      template<typename _Ch_traits, typename _Ch_alloc>
-        explicit
-        basic_regex(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
-		    flag_type __f = regex_constants::ECMAScript)
-	: _M_flags(__f), _M_pattern(__s), _M_mark_count(0)
-        { _M_compile(); }
-
-      /**
-       * @brief Constructs a basic regular expression from the range
-       * [first, last) interpreted according to the flags in @p f.
-       *
-       * @param first The start of arange containing a valid regular
-       *              expression.
-       * @param last  The end of a range containing a valid regular
-       *              expression.
-       * @param f     The format flags of the regular expression.
-       *
-       * @throws regex_error if @p p is not a valid regular expression.
-       */
-      template<typename _InputIterator>
-        basic_regex(_InputIterator __first, _InputIterator __last, 
-		    flag_type __f = regex_constants::ECMAScript)
-	: _M_flags(__f), _M_pattern(__first, __last), _M_mark_count(0)
-        { _M_compile(); }
-
-      /**
-       * @brief Destroys a basic regular expression.
-       */
-      ~basic_regex()
-      { }
-      
-      /**
-       * @brief Assigns one regular expression to another.
-       */
-      basic_regex&
-      operator=(const basic_regex& __rhs)
-      { return this->assign(__rhs); }
-
-      /**
-       * @brief Replaces a regular expression with a new one constructed from
-       * a C-style null-terminated string.
-       *
-       * @param A pointer to the start of a null-terminated C-style string
-       *        containing a regular expression.
-       */
-      basic_regex&
-      operator=(const _Ch_type* __p)
-      { return this->assign(__p, flags()); }
-      
-      /**
-       * @brief Replaces a regular expression with a new one constructed from
-       * a string.
-       *
-       * @param A pointer to a string containing a regular expression.
-       */
-      template<typename _Ch_typeraits, typename _Allocator>
-        basic_regex&
-        operator=(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s)
-        { return this->assign(__s, flags()); }
-
-      // [7.8.3] assign
-      /**
-       * @brief the real assignment operator.
-       *
-       * @param that Another regular expression object.
-       */
-      basic_regex&
-      assign(const basic_regex& __that)
-      {
-	basic_regex __tmp(__that);
-	this->swap(__tmp);
-	return *this;
-      }
-      
-      /**
-       * @brief Assigns a new regular expression to a regex object from a
-       * C-style null-terminated string containing a regular expression
-       * pattern.
-       *
-       * @param p     A pointer to a C-style null-terminated string containing
-       *              a regular expression pattern.
-       * @param flags Syntax option flags.
-       *
-       * @throws regex_error if p does not contain a valid regular expression
-       * pattern interpreted according to @p flags.  If regex_error is thrown,
-       * *this remains unchanged.
-       */
-      basic_regex&
-      assign(const _Ch_type* __p,
-	     flag_type __flags = regex_constants::ECMAScript)
-      { return this->assign(string_type(__p), __flags); }
-
-      /**
-       * @brief Assigns a new regular expression to a regex object from a
-       * C-style string containing a regular expression pattern.
-       *
-       * @param p     A pointer to a C-style string containing a
-       *              regular expression pattern.
-       * @param len   The length of the regular expression pattern string.
-       * @param flags Syntax option flags.
-       *
-       * @throws regex_error if p does not contain a valid regular expression
-       * pattern interpreted according to @p flags.  If regex_error is thrown,
-       * *this remains unchanged.
-       */
-      basic_regex&
-      assign(const _Ch_type* __p, std::size_t __len, flag_type __flags)
-      { return this->assign(string_type(__p, __len), __flags); }
-
-      /**
-       * @brief Assigns a new regular expression to a regex object from a 
-       * string containing a regular expression pattern.
-       *
-       * @param s     A string containing a regular expression pattern.
-       * @param flags Syntax option flags.
-       *
-       * @throws regex_error if p does not contain a valid regular expression
-       * pattern interpreted according to @p flags.  If regex_error is thrown,
-       * *this remains unchanged.
-       */
-      template<typename _Ch_typeraits, typename _Allocator>
-        basic_regex&
-        assign(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s,
-	       flag_type __f = regex_constants::ECMAScript)
-        { 
-	  basic_regex __tmp(__s, __f);
-	  this->swap(__tmp);
-	  return *this;
-	}
-
-      /**
-       * @brief Assigns a new regular expression to a regex object.
-       *
-       * @param first The start of a range containing a valid regular
-       *              expression.
-       * @param last  The end of a range containing a valid regular
-       *              expression.
-       * @param flags Syntax option flags.
-       *
-       * @throws regex_error if p does not contain a valid regular expression
-       * pattern interpreted according to @p flags.  If regex_error is thrown,
-       * *this remains unchanged.
-       */
-      template<typename _InputIterator>
-        basic_regex&
-        assign(_InputIterator __first, _InputIterator __last,
-	       flag_type __flags = regex_constants::ECMAScript)
-        { return this->assign(string_type(__first, __last), __flags); }
-
-      // [7.8.4] const operations
-      /**
-       * @brief Gets the number of marked subexpressions within the regular
-       * expresison.
-       */
-      unsigned int
-      mark_count() const
-      { return _M_mark_count; }
-      
-      /**
-       * @brief Gets the flags used to construct the regular expression
-       * or in the last call to assign().
-       */
-      flag_type
-      flags() const
-      { return _M_flags; }
-      
-      // [7.8.5] locale
-      /**
-       * @brief Imbues the regular expression object with the given locale.
-       *
-       * @param loc A locale.
-       */
-      locale_type
-      imbue(locale_type __loc)
-      { return _M_traits.imbue(__loc); }
-      
-      /**
-       * @brief Gets the locale currently imbued in the regular expression
-       *        object.
-       */
-      locale_type
-      getloc() const
-      { return _M_traits.getloc(); }
-      
-      // [7.8.6] swap
-      /**
-       * @brief Swaps the contents of two regular expression obects.
-       *
-       * @param rhs Another regular expression object.
-       */
-      void
-      swap(basic_regex& __rhs)
-      {
-	std::swap(_M_flags,      __rhs._M_flags);
-	std::swap(_M_pattern,    __rhs._M_pattern);
-	std::swap(_M_mark_count, __rhs._M_mark_count);
-	std::swap(_M_traits,     __rhs._M_traits);
-      }
-      
-    private:
-      /**
-       * @brief Compiles a regular expression pattern into a NFA.
-       * @todo Implement this function.
-       */
-      void _M_compile()
-      { }
-
-    protected:
-      flag_type    _M_flags;
-      string_type  _M_pattern;
-      unsigned int _M_mark_count;
-      _Rx_traits   _M_traits;
-    };
-  
-  typedef basic_regex<char>    regex;
-#ifdef _GLIBCXX_USE_WCHAR_T
-  typedef basic_regex<wchar_t> wregex;
-#endif
-
-
-  // [7.8.6] basic_regex swap
-  /**
-   * @brief Swaps the contents of two regular expression objects.
-   * @param lhs First regular expression.
-   * @param rhs Second regular expression.
-   */
-  template<typename _Ch_type, typename _Rx_traits>
-    inline void
-    swap(basic_regex<_Ch_type, _Rx_traits>& __lhs,
-	 basic_regex<_Ch_type, _Rx_traits>& __rhs)
-    { return __lhs.swap(__rhs); }
-
-
-  // [7.9] Class template sub_match
-  /**
-   * A sequence of characters matched by a particular marked sub-expression.
-   *
-   * An object of this class is essentially a pair of iterators marking a
-   * matched subexpression within a regular expression pattern match. Such
-   * objects can be converted to and compared with std::basic_string objects
-   * of a similar base character type as the pattern matched by the regular
-   * expression.
-   *
-   * The iterators that make up the pair are the usual half-open interval
-   * referencing the actual original pattern matched.
-   */
-  template<typename _BiIter>
-    class sub_match : public std::pair<_BiIter, _BiIter>
-    {
-    public:
-      typedef typename iterator_traits<_BiIter>::value_type      value_type;
-      typedef typename iterator_traits<_BiIter>::difference_type
-                                                            difference_type;
-      typedef _BiIter                                              iterator;
-
-    public:
-      bool matched;
-      
-      /**
-       * Gets the length of the matching sequence.
-       */
-      difference_type
-      length() const
-      { return this->matched ? std::distance(this->first, this->second) : 0; }
-
-      /**
-       * @brief Gets the matching sequence as a string.
-       *
-       * @returns the matching sequence as a string.
-       *
-       * This is the implicit conversion operator.  It is identical to the
-       * str() member function except that it will want to pop up in
-       * unexpected places and cause a great deal of confusion and cursing
-       * from the unwary.
-       */
-      operator basic_string<value_type>() const
-      {
-	return this->matched
-	  ? std::basic_string<value_type>(this->first, this->second)
-	  : std::basic_string<value_type>();
-      }
-      
-      /**
-       * @brief Gets the matching sequence as a string.
-       *
-       * @returns the matching sequence as a string.
-       */
-      basic_string<value_type>
-      str() const
-      {
-	return this->matched
-	  ? std::basic_string<value_type>(this->first, this->second)
-	  : std::basic_string<value_type>();
-      }
-      
-      /**
-       * @brief Compares this and another matched sequence.
-       *
-       * @param s Another matched sequence to compare to this one.
-       *
-       * @retval <0 this matched sequence will collate before @p s.
-       * @retval =0 this matched sequence is equivalent to @p s.
-       * @retval <0 this matched sequence will collate after @p s.
-       */
-      int
-      compare(const sub_match& __s) const
-      { return this->str().compare(__s.str()); }
-
-      /**
-       * @brief Compares this sub_match to a string.
-       *
-       * @param s A string to compare to this sub_match.
-       *
-       * @retval <0 this matched sequence will collate before @p s.
-       * @retval =0 this matched sequence is equivalent to @p s.
-       * @retval <0 this matched sequence will collate after @p s.
-       */
-      int
-      compare(const basic_string<value_type>& __s) const
-      { return this->str().compare(__s); }
-      
-      /**
-       * @brief Compares this sub_match to a C-style string.
-       *
-       * @param s A C-style string to compare to this sub_match.
-       *
-       * @retval <0 this matched sequence will collate before @p s.
-       * @retval =0 this matched sequence is equivalent to @p s.
-       * @retval <0 this matched sequence will collate after @p s.
-       */
-      int
-      compare(const value_type* __s) const
-      { return this->str().compare(__s); }
-    };
-  
-  
-  typedef sub_match<const char*>             csub_match;
-  typedef sub_match<string::const_iterator>  ssub_match;
-#ifdef _GLIBCXX_USE_WCHAR_T
-  typedef sub_match<const wchar_t*>          wcsub_match;
-  typedef sub_match<wstring::const_iterator> wssub_match;
-#endif
-
-  // [7.9.2] sub_match non-member operators
-  
-  /**
-   * @brief Tests the equivalence of two regular expression submatches.
-   * @param lhs First regular expression submatch.
-   * @param rhs Second regular expression submatch.
-   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
-   */
-  template<typename _BiIter>
-    inline bool
-    operator==(const sub_match<_BiIter>& __lhs,
-	       const sub_match<_BiIter>& __rhs)
-    { return __lhs.compare(__rhs) == 0; }
-
-  /**
-   * @brief Tests the inequivalence of two regular expression submatches.
-   * @param lhs First regular expression submatch.
-   * @param rhs Second regular expression submatch.
-   * @returns true if @a lhs  is not equivalent to @a rhs, false otherwise.
-   */
-  template<typename _BiIter>
-    inline bool
-    operator!=(const sub_match<_BiIter>& __lhs,
-	       const sub_match<_BiIter>& __rhs)
-    { return __lhs.compare(__rhs) != 0; }
-
-  /**
-   * @brief Tests the ordering of two regular expression submatches.
-   * @param lhs First regular expression submatch.
-   * @param rhs Second regular expression submatch.
-   * @returns true if @a lhs precedes @a rhs, false otherwise.
-   */
-  template<typename _BiIter>
-    inline bool
-    operator<(const sub_match<_BiIter>& __lhs,
-	      const sub_match<_BiIter>& __rhs)
-    { return __lhs.compare(__rhs) < 0; }
-
-  /**
-   * @brief Tests the ordering of two regular expression submatches.
-   * @param lhs First regular expression submatch.
-   * @param rhs Second regular expression submatch.
-   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
-   */
-  template<typename _BiIter>
-    inline bool
-    operator<=(const sub_match<_BiIter>& __lhs,
-	       const sub_match<_BiIter>& __rhs)
-    { return __lhs.compare(__rhs) <= 0; }
-
-  /**
-   * @brief Tests the ordering of two regular expression submatches.
-   * @param lhs First regular expression submatch.
-   * @param rhs Second regular expression submatch.
-   * @returns true if @a lhs does not preceed @a rhs, false otherwise.
-   */
-  template<typename _BiIter>
-    inline bool
-    operator>=(const sub_match<_BiIter>& __lhs,
-	       const sub_match<_BiIter>& __rhs)
-    { return __lhs.compare(__rhs) >= 0; }
-
-  /**
-   * @brief Tests the ordering of two regular expression submatches.
-   * @param lhs First regular expression submatch.
-   * @param rhs Second regular expression submatch.
-   * @returns true if @a lhs succeeds @a rhs, false otherwise.
-   */
-  template<typename _BiIter>
-    inline bool
-    operator>(const sub_match<_BiIter>& __lhs,
-	      const sub_match<_BiIter>& __rhs)
-    { return __lhs.compare(__rhs) > 0; }
-
-  /**
-   * @brief Tests the equivalence of a string and a regular expression
-   *        submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
-    inline bool
-    operator==(const basic_string<
-	       typename iterator_traits<_Bi_iter>::value_type,
-	       _Ch_traits, _Ch_alloc>& __lhs,
-	       const sub_match<_Bi_iter>& __rhs)
-    { return __lhs == __rhs.str(); }
-
-  /**
-   * @brief Tests the inequivalence of a string and a regular expression
-   *        submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs  is not equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
-    inline bool
-    operator!=(const basic_string<
-	       typename iterator_traits<_Bi_iter>::value_type,
-	       _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
-    { return __lhs != __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs precedes @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
-    inline bool
-    operator<(const basic_string<
-	      typename iterator_traits<_Bi_iter>::value_type,
-	      _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
-     { return __lhs < __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs succeeds @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
-    inline bool
-    operator>(const basic_string<
-	      typename iterator_traits<_Bi_iter>::value_type, 
-	      _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
-    { return __lhs > __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs does not preceed @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
-    inline bool
-    operator>=(const basic_string<
-	       typename iterator_traits<_Bi_iter>::value_type,
-	       _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
-    { return __lhs >= __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
-    inline bool
-    operator<=(const basic_string<
-	       typename iterator_traits<_Bi_iter>::value_type,
-	       _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
-    { return __lhs <= __rhs.str(); }
-
-  /**
-   * @brief Tests the equivalence of a regular expression submatch and a
-   *        string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
-    inline bool
-    operator==(const sub_match<_Bi_iter>& __lhs,
-	       const basic_string<
-	       typename iterator_traits<_Bi_iter>::value_type,
-	       _Ch_traits, _Ch_alloc>& __rhs)
-    { return __lhs.str() == __rhs; }
-
-  /**
-   * @brief Tests the inequivalence of a regular expression submatch and a
-   *        string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
-    inline bool
-    operator!=(const sub_match<_Bi_iter>& __lhs,
-	       const basic_string<
-	       typename iterator_traits<_Bi_iter>::value_type,
-	       _Ch_traits, _Ch_alloc>& __rhs)
-    { return __lhs.str() != __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs precedes @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
-    inline bool
-    operator<(const sub_match<_Bi_iter>& __lhs,
-	      const basic_string<
-	      typename iterator_traits<_Bi_iter>::value_type,
-	      _Ch_traits, _Ch_alloc>& __rhs)
-    { return __lhs.str() < __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs succeeds @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
-    inline bool
-    operator>(const sub_match<_Bi_iter>& __lhs,
-	      const basic_string<
-	      typename iterator_traits<_Bi_iter>::value_type,
-	      _Ch_traits, _Ch_alloc>& __rhs)
-    { return __lhs.str() > __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs does not preceed @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
-    inline bool
-    operator>=(const sub_match<_Bi_iter>& __lhs,
-	       const basic_string<
-	       typename iterator_traits<_Bi_iter>::value_type,
-	       _Ch_traits, _Ch_alloc>& __rhs)
-    { return __lhs.str() >= __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
-    inline bool
-    operator<=(const sub_match<_Bi_iter>& __lhs,
-	       const basic_string<
-	       typename iterator_traits<_Bi_iter>::value_type,
-	       _Ch_traits, _Ch_alloc>& __rhs)
-    { return __lhs.str() <= __rhs; }
-
-  /**
-   * @brief Tests the equivalence of a C string and a regular expression
-   *        submatch.
-   * @param lhs A C string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator==(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
-	       const sub_match<_Bi_iter>& __rhs)
-    { return __lhs == __rhs.str(); }
-
-  /**
-   * @brief Tests the inequivalence of an iterator value and a regular
-   *        expression submatch.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator!=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
-	       const sub_match<_Bi_iter>& __rhs)
-    { return __lhs != __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs precedes @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator<(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
-	      const sub_match<_Bi_iter>& __rhs)
-    { return __lhs < __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs succeeds @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator>(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
-	      const sub_match<_Bi_iter>& __rhs)
-    { return __lhs > __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs does not preceed @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator>=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
-	       const sub_match<_Bi_iter>& __rhs)
-    { return __lhs >= __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator<=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
-	       const sub_match<_Bi_iter>& __rhs)
-    { return __lhs <= __rhs.str(); }
-
-  /**
-   * @brief Tests the equivalence of a regular expression submatch and a
-   *        string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A pointer to a string?
-   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator==(const sub_match<_Bi_iter>& __lhs,
-	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
-    { return __lhs.str() == __rhs; }
-
-  /**
-   * @brief Tests the inequivalence of a regular expression submatch and a
-   *        string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A pointer to a string.
-   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator!=(const sub_match<_Bi_iter>& __lhs,
-	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
-    { return __lhs.str() != __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs precedes @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator<(const sub_match<_Bi_iter>& __lhs,
-	      typename iterator_traits<_Bi_iter>::value_type const* __rhs)
-    { return __lhs.str() < __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs succeeds @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator>(const sub_match<_Bi_iter>& __lhs,
-	      typename iterator_traits<_Bi_iter>::value_type const* __rhs)
-    { return __lhs.str() > __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs does not precede @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator>=(const sub_match<_Bi_iter>& __lhs,
-	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
-    { return __lhs.str() >= __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator<=(const sub_match<_Bi_iter>& __lhs,
-	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
-    { return __lhs.str() <= __rhs; }
-
-  /**
-   * @brief Tests the equivalence of a string and a regular expression
-   *        submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator==(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
-	       const sub_match<_Bi_iter>& __rhs)
-    { return __lhs == __rhs.str(); }
-
-  /**
-   * @brief Tests the inequivalence of a string and a regular expression
-   *        submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator!=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
-	       const sub_match<_Bi_iter>& __rhs)
-    { return __lhs != __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs precedes @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator<(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
-	      const sub_match<_Bi_iter>& __rhs)
-    { return __lhs < __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs succeeds @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator>(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
-	      const sub_match<_Bi_iter>& __rhs)
-    { return __lhs > __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs does not preceed @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator>=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
-	       const sub_match<_Bi_iter>& __rhs)
-    { return __lhs >= __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator<=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
-	       const sub_match<_Bi_iter>& __rhs)
-    { return __lhs <= __rhs.str(); }
-
-  /**
-   * @brief Tests the equivalence of a regular expression submatch and a
-   *        string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A const string reference.
-   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator==(const sub_match<_Bi_iter>& __lhs,
-	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
-    { return __lhs.str() == __rhs; }
-
-  /**
-   * @brief Tests the inequivalence of a regular expression submatch and a
-   *        string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A const string reference.
-   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator!=(const sub_match<_Bi_iter>& __lhs,
-	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
-    { return __lhs.str() != __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A const string reference.
-   * @returns true if @a lhs preceeds @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator<(const sub_match<_Bi_iter>& __lhs,
-	      typename iterator_traits<_Bi_iter>::value_type const& __rhs)
-    { return __lhs.str() < __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A const string reference.
-   * @returns true if @a lhs succeeds @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator>(const sub_match<_Bi_iter>& __lhs,
-	      typename iterator_traits<_Bi_iter>::value_type const& __rhs)
-    { return __lhs.str() > __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A const string reference.
-   * @returns true if @a lhs does not preceed @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator>=(const sub_match<_Bi_iter>& __lhs,
-	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
-    { return __lhs.str() >= __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A const string reference.
-   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator<=(const sub_match<_Bi_iter>& __lhs,
-	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
-    { return __lhs.str() <= __rhs; }
-
-  /**
-   * @brief Inserts a matched string into an output stream.
-   *
-   * @param os The output stream.
-   * @param m  A submatch string.
-   *
-   * @returns the output stream with the submatch string inserted.
-   */
-  template<typename _Ch_type, typename _Ch_traits, typename _Bi_iter>
-    inline
-    basic_ostream<_Ch_type, _Ch_traits>&
-    operator<<(basic_ostream<_Ch_type, _Ch_traits>& __os,
-	       const sub_match<_Bi_iter>& __m)
-    { return __os << __m.str(); }
-
-  // [7.10] Class template match_results
-  /**
-   * A collection of character sequences representing the result of a regular
-   * expression match.  Storage for the collection is allocated and freed as
-   * necessary by the member functions of class template match_results.
-   *
-   * This class satisfies the Sequence requirements, with the exception that
-   * only the operations defined for a const-qualified Sequence are supported.
-   *
-   * The sub_match object stored at index 0 represents sub-expression 0, i.e.
-   * the whole match. In this case the sub_match member matched is always true.
-   * The sub_match object stored at index n denotes what matched the marked
-   * sub-expression n within the matched expression. If the sub-expression n
-   * participated in a regular expression match then the sub_match member
-   * matched evaluates to true, and members first and second denote the range
-   * of characters [first, second) which formed that match. Otherwise matched
-   * is false, and members first and second point to the end of the sequence
-   * that was searched.
-   */
-  template<typename _Bi_iter,
-	   typename _Allocator = allocator<sub_match<_Bi_iter> > >
-    class match_results
-    : private std::vector<std::_GLIBCXX_TR1::sub_match<_Bi_iter>, _Allocator>
-    {
-    private:
-      typedef std::vector<std::_GLIBCXX_TR1::sub_match<_Bi_iter>, _Allocator>
-                                                              _Base_type;
-
-    public:
-      typedef sub_match<_Bi_iter>                             value_type;
-      typedef typename _Allocator::const_reference            const_reference;
-      typedef const_reference                                 reference;
-      typedef typename _Base_type::const_iterator             const_iterator;
-      typedef const_iterator                                  iterator;
-      typedef typename iterator_traits<_Bi_iter>::difference_type
-                                                              difference_type;
-      typedef typename _Allocator::size_type                  size_type;
-      typedef _Allocator                                      allocator_type;
-      typedef typename iterator_traits<_Bi_iter>::value_type  char_type;
-      typedef basic_string<char_type>                         string_type;
-  
-    public:
-      // [7.10.1] construct/copy/destroy
-      /**
-       * @brief Constructs a default match_results container.
-       */
-      explicit
-      match_results(const _Allocator& __a = _Allocator())
-      : _Base_type(__a), _M_matched(false)
-      { }
-
-      /**
-       * @brief Copy constructs a match_result.
-       */
-      match_results(const match_results& __rhs)
-      : _Base_type(__rhs), _M_matched(__rhs._M_matched),
-	_M_prefix(__rhs._M_prefix), _M_suffix(__rhs._M_suffix)
-      { }
-
-      /**
-       * @brief Assigns rhs to *this.
-       */
-      match_results&
-      operator=(const match_results& __rhs)
-      {
-	match_results __tmp(__rhs);
-	this->swap(__tmp);
-      }
-
-      /**
-       * @todo Implement this function.
-       */
-      ~match_results()
-      { }
-      
-      // [7.10.2] size
-      /**
-       * @todo Document this function.
-       */
-      size_type
-      size() const
-      { return _M_matched ? _Base_type::size() + 1 : 0; }
-      
-      /**
-       * @todo Implement this function.
-       */
-      //size_type
-      //max_size() const;
-      using _Base_type::max_size;
-
-      /**
-       * @todo Document this function.
-       */
-      bool
-      empty() const
-      { return size() == 0; }
-      
-      // [7.10.3] element access
-      /**
-       * @brief Gets the length of the indicated submatch.
-       * @param sub indicates the submatch.
-       */
-      difference_type
-      length(size_type __sub = 0) const
-      { return _M_matched ? this->str(__sub).length() : 0; }
-
-      /**
-       * @todo Document this function.
-       */
-      difference_type
-      position(size_type __sub = 0) const
-      {
-	return _M_matched ? std::distance(this->prefix().first,
-					  (*this)[__sub].first) : 0;
-      }
-
-      /**
-       * @todo Document this function.
-       */
-      string_type
-      str(size_type __sub = 0) const
-      { return _M_matched ? (*this)[__sub].str() : string_type(); }
-      
-      /**
-       * @todo Document this function.
-       */
-      const_reference
-      operator[](size_type __n) const
-      { return _Base_type::operator[](__n); }
-
-      /**
-       * @todo Document this function.
-       */
-      const_reference
-      prefix() const
-      { return _M_prefix; }
-
-      /**
-       * @todo Document this function.
-       */
-      const_reference
-      suffix() const
-      { return _M_suffix; }
-
-      /**
-       * @todo Document this function.
-       */
-      const_iterator
-      begin() const
-      { return _Base_type::begin(); }
-      
-      /**
-       * @todo Document this function.
-       */
-      const_iterator
-      end() const
-      { return _Base_type::end(); }
-      
-      // [7.10.4] format
-      /**
-       * @todo Implement this function.
-       */
-      template<typename _Out_iter>
-        _Out_iter
-        format(_Out_iter __out, const string_type& __fmt,
-	       regex_constants::match_flag_type __flags
-	       = regex_constants::format_default) const
-        { return __out; }
-
-      /**
-       * @todo Implement this function.
-       */
-      string_type
-      format(const string_type& __fmt,
-	     regex_constants::match_flag_type __flags
-	     = regex_constants::format_default) const;
-
-      // [7.10.5] allocator
-      /**
-       * @todo Document this function.
-       */
-      //allocator_type
-      //get_allocator() const;
-      using _Base_type::get_allocator;
-      
-      // [7.10.6] swap
-      /**
-       * @todo Document this function.
-       */
-      void
-      swap(match_results& __that)
-      {
-	_Base_type::swap(__that);
-	std::swap(_M_matched, __that._M_matched);
-	std::swap(_M_prefix,  __that._M_prefix);
-	std::swap(_M_suffix,  __that._M_suffix);
-      }
-      
-    private:
-      bool       _M_matched;
-      value_type _M_prefix;
-      value_type _M_suffix;
-    };
-  
-  typedef match_results<const char*>             cmatch;
-  typedef match_results<string::const_iterator>  smatch;
-#ifdef _GLIBCXX_USE_WCHAR_T
-  typedef match_results<const wchar_t*>          wcmatch;
-  typedef match_results<wstring::const_iterator> wsmatch;
-#endif
-
-  // match_results comparisons
-  /**
-   * @todo Implement this function.
-   */
-  template<typename _Bi_iter, typename _Allocator>
-    inline bool
-    operator==(const match_results<_Bi_iter, _Allocator>& __m1,
-	       const match_results<_Bi_iter, _Allocator>& __m2);
-
-  /**
-   * @todo Implement this function.
-   */
-  template<typename _Bi_iter, class _Allocator>
-    inline bool
-    operator!=(const match_results<_Bi_iter, _Allocator>& __m1,
-	       const match_results<_Bi_iter, _Allocator>& __m2);
-
-  // [7.10.6] match_results swap
-  /**
-   * @brief Swaps two match results.
-   * @param lhs A match result.
-   * @param rhs A match result.
-   *
-   * The contents of the two match_results objects are swapped.
-   */
-  template<typename _Bi_iter, typename _Allocator>
-    inline void
-    swap(match_results<_Bi_iter, _Allocator>& __lhs,
-	 match_results<_Bi_iter, _Allocator>& __rhs)
-    { return __lhs.swap(__rhs); }
-
-  // [7.11.2] Function template regex_match
-  /**
-   * @brief Determines if there is a match between the regular expression @p e
-   * and all of the character sequence [first, last).
-   *
-   * @param first Beginning of the character sequence to match.
-   * @param last  One-past-the-end of the character sequence to match.
-   * @param m     The match results.
-   * @param re    The regular expression.
-   * @param flags Controls how the regular expression is matched.
-   *
-   * @retval true  A match exists.
-   * @retval false Otherwise.
-   *
-   * @todo Implement this function.
-   */
-  template<typename _Bi_iter, typename _Allocator,
-	   typename _Ch_type, typename _Rx_traits>
-    bool
-    regex_match(_Bi_iter __first, _Bi_iter __last,
-		match_results<_Bi_iter, _Allocator>& __m,
-		const basic_regex<_Ch_type, _Rx_traits>& __re,
-		regex_constants::match_flag_type __flags
-		= regex_constants::match_default)
-    { return false; }
-
-  /**
-   * @brief Indicates if there is a match between the regular expression @p e
-   * and all of the character sequence [first, last).
-   *
-   * @param first Beginning of the character sequence to match.
-   * @param last  One-past-the-end of the character sequence to match.
-   * @param re    The regular expression.
-   * @param flags Controls how the regular expression is matched.
-   *
-   * @retval true  A match exists.
-   * @retval false Otherwise.
-   */
-  template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
-    bool
-    regex_match(_Bi_iter __first, _Bi_iter __last,
-		const basic_regex<_Ch_type, _Rx_traits>& __re,
-		regex_constants::match_flag_type __flags
-		= regex_constants::match_default)
-    { 
-      match_results<_Bi_iter> __what;
-      return regex_match(__first, __last, __what, __re, __flags);
-    }
-
-  /**
-   * @brief Determines if there is a match between the regular expression @p e
-   * and a C-style null-terminated string.
-   *
-   * @param s  The C-style null-terminated string to match.
-   * @param m  The match results.
-   * @param re The regular expression.
-   * @param f  Controls how the regular expression is matched.
-   *
-   * @retval true  A match exists.
-   * @retval false Otherwise.
-   */
-  template<typename _Ch_type, typename _Allocator, typename _Rx_traits>
-    inline bool
-    regex_match(const _Ch_type* __s,
-		match_results<const _Ch_type*, _Allocator>& __m,
-		const basic_regex<_Ch_type, _Rx_traits>& __re,
-		regex_constants::match_flag_type __f
-		= regex_constants::match_default)
-    { return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); }
-
-  /**
-   * @brief Determines if there is a match between the regular expression @p e
-   * and a string.
-   *
-   * @param s     The string to match.
-   * @param m     The match results.
-   * @param re    The regular expression.
-   * @param flags Controls how the regular expression is matched.
-   *
-   * @retval true  A match exists.
-   * @retval false Otherwise.
-   */
-  template<typename _Ch_traits, typename _Ch_alloc,
-	   typename _Allocator, typename _Ch_type, typename _Rx_traits>
-    inline bool
-    regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
-		match_results<typename basic_string<_Ch_type, 
-		_Ch_traits, _Ch_alloc>::const_iterator, _Allocator>& __m,
-		const basic_regex<_Ch_type, _Rx_traits>& __re,
-		regex_constants::match_flag_type __flags
-		= regex_constants::match_default)
-    { return regex_match(__s.begin(), __s.end(), __m, __re, __flags); }
-
-  /**
-   * @brief Indicates if there is a match between the regular expression @p e
-   * and a C-style null-terminated string.
-   *
-   * @param s  The C-style null-terminated string to match.
-   * @param re The regular expression.
-   * @param f  Controls how the regular expression is matched.
-   *
-   * @retval true  A match exists.
-   * @retval false Otherwise.
-   */
-  template<typename _Ch_type, class _Rx_traits>
-    inline bool
-    regex_match(const _Ch_type* __s,
-		const basic_regex<_Ch_type, _Rx_traits>& __re,
-		regex_constants::match_flag_type __f
-		= regex_constants::match_default)
-    { return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); }
-
-  /**
-   * @brief Indicates if there is a match between the regular expression @p e
-   * and a string.
-   *
-   * @param s     [IN] The string to match.
-   * @param re    [IN] The regular expression.
-   * @param flags [IN] Controls how the regular expression is matched.
-   *
-   * @retval true  A match exists.
-   * @retval false Otherwise.
-   */
-  template<typename _Ch_traits, typename _Str_allocator,
-	   typename _Ch_type, typename _Rx_traits>
-    inline bool
-    regex_match(const basic_string<_Ch_type, _Ch_traits, _Str_allocator>& __s,
-		const basic_regex<_Ch_type, _Rx_traits>& __re,
-		regex_constants::match_flag_type __flags
-		= regex_constants::match_default)
-    { return regex_match(__s.begin(), __s.end(), __re, __flags); }
-
-  // [7.11.3] Function template regex_search
-  /**
-   * Searches for a regular expression within a range.
-   * @param first [IN]  The start of the string to search.
-   * @param last  [IN]  One-past-the-end of the string to search.
-   * @param m     [OUT] The match results.
-   * @param re    [IN]  The regular expression to search for.
-   * @param flags [IN]  Search policy flags.
-   * @retval true  A match was found within the string.
-   * @retval false No match was found within the string, the content of %m is
-   *               undefined.
-   * @todo Implement this function.
-   */
-  template<typename _Bi_iter, typename _Allocator,
-	   typename _Ch_type, typename _Rx_traits>
-    inline bool
-    regex_search(_Bi_iter __first, _Bi_iter __last,
-		 match_results<_Bi_iter, _Allocator>& __m,
-		 const basic_regex<_Ch_type, _Rx_traits>& __re,
-		 regex_constants::match_flag_type __flags
-		 = regex_constants::match_default)
-    { return false; }
-
-  /**
-   * Searches for a regular expression within a range.
-   * @param first [IN]  The start of the string to search.
-   * @param last  [IN]  One-past-the-end of the string to search.
-   * @param re    [IN]  The regular expression to search for.
-   * @param flags [IN]  Search policy flags.
-   * @retval true  A match was found within the string.
-   * @retval false No match was found within the string.
-   * @todo Document me.
-   */
-  template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
-    inline bool
-    regex_search(_Bi_iter __first, _Bi_iter __last,
-		 const basic_regex<_Ch_type, _Rx_traits>& __re,
-		 regex_constants::match_flag_type __flags
-		 = regex_constants::match_default)
-    {
-      match_results<_Bi_iter> __what;
-      return regex_search(__first, __last, __what, __re, __flags);
-    }
-
-  /**
-   * @brief Searches for a regular expression within a C-string.
-   * @param s [IN]  A C-string to search for the regex.
-   * @param m [OUT] The set of regex mnatches.
-   * @param e [IN]  The regex to search for in @p s.
-   * @param f [IN]  The search flags.
-   * @retval true  A match was found within the string.
-   * @retval false No match was found within the string, the content of %m is
-   *               undefined.
-   * @todo Document me.
-   */
-  template<typename _Ch_type, class _Allocator, class _Rx_traits>
-    inline bool
-    regex_search(const _Ch_type* __s,
-		 match_results<const _Ch_type*, _Allocator>& __m,
-		 const basic_regex<_Ch_type, _Rx_traits>& __e,
-		 regex_constants::match_flag_type __f
-		 = regex_constants::match_default)
-    { return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); }
-
-  /**
-   * @brief Searches for a regular expression within a C-string.
-   * @param s [IN]  The C-string to search.
-   * @param e [IN]  The regular expressioon to search for.
-   * @param f [IN]  Search policy flags.
-   * @retval true  A match was found within the string.
-   * @retval false No match was found within the string.
-   * @todo Document me.
-   */
-  template<typename _Ch_type, typename _Rx_traits>
-    inline bool
-    regex_search(const _Ch_type* __s,
-		 const basic_regex<_Ch_type, _Rx_traits>& __e,
-		 regex_constants::match_flag_type __f
-		 = regex_constants::match_default)
-    { return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); }
-
-  /**
-   * @brief Searches for a regular expression within a string.
-   * @param s     [IN]  The string to search.
-   * @param e     [IN]  The regular expressioon to search for.
-   * @param flags [IN]  Search policy flags.
-   * @retval true  A match was found within the string.
-   * @retval false No match was found within the string.
-   * @todo Document me.
-   */
-  template<typename _Ch_traits, typename _String_allocator,
-	   typename _Ch_type, typename _Rx_traits>
-    inline bool
-    regex_search(const basic_string<_Ch_type, _Ch_traits,
-		 _String_allocator>& __s,
-		 const basic_regex<_Ch_type, _Rx_traits>& __e,
-		 regex_constants::match_flag_type __flags
-		 = regex_constants::match_default)
-    { return regex_search(__s.begin(), __s.end(), __e, __flags); }
-
-  /**
-   * @brief Searches for a regular expression within a string.
-   * @param s [IN]  A C++ string to search for the regex.
-   * @param m [OUT] The set of regex mnatches.
-   * @param e [IN]  The regex to search for in @p s.
-   * @param f [IN]  The search flags.
-   * @retval true  A match was found within the string.
-   * @retval false No match was found within the string, the content of %m is
-   *               undefined.
-   */
-  template<typename _Ch_traits, typename _Ch_alloc,
-	   typename _Allocator, typename _Ch_type,
-	   typename _Rx_traits>
-    inline bool
-    regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
-		 match_results<typename basic_string<_Ch_type,
-		 _Ch_traits, _Ch_alloc>::const_iterator, _Allocator>& __m,
-		 const basic_regex<_Ch_type, _Rx_traits>& __e,
-		 regex_constants::match_flag_type __f
-		 = regex_constants::match_default)
-    { return regex_search(__s.begin(), __s.end(), __m, __e, __f); }
-
-  // [7.11.4] Function template regex_replace
-  /**
-   * @todo Implement this function.
-   * @todo Document this function.
-   */
-  template<typename _Out_iter, typename _Bi_iter,
-	   typename _Rx_traits, typename _Ch_type>
-    inline _Out_iter
-    regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
-		  const basic_regex<_Ch_type, _Rx_traits>& __e,
-		  const basic_string<_Ch_type>& __fmt,
-		  regex_constants::match_flag_type __flags
-		  = regex_constants::match_default)
-    { return __out; }
-
-  /**
-   * @todo Document me.
-   */
-  template<typename _Rx_traits, typename _Ch_type>
-    inline basic_string<_Ch_type>
-    regex_replace(const basic_string<_Ch_type>& __s,
-		  const basic_regex<_Ch_type, _Rx_traits>& __e,
-		  const basic_string<_Ch_type>& __fmt,
-		  regex_constants::match_flag_type __flags
-		  = regex_constants::match_default)
-    {
-      std::string __result;
-      regex_replace(std::back_inserter(__result),
-		    __s.begin(), __s.end(), __e, __fmt, __flags);
-      return __result;
-    }
-
-  // [7.12.1] Class template regex_iterator
-  /**
-   * An iterator adaptor that will provide repeated calls of regex_search over 
-   * a range until no more matches remain.
-   */
-  template<typename _Bi_iter,
-	   typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
-	   typename _Rx_traits = regex_traits<_Ch_type> >
-    class regex_iterator
-    {
-    public:
-      typedef basic_regex<_Ch_type, _Rx_traits>  regex_type;
-      typedef match_results<_Bi_iter>            value_type;
-      typedef std::ptrdiff_t                     difference_type;
-      typedef const value_type*                  pointer;
-      typedef const value_type&                  reference;
-      typedef std::forward_iterator_tag          iterator_category;
-
-    public:
-      /**
-       * @brief Provides a singular iterator, useful for indicating
-       * one-past-the-end of a range.
-       * @todo Implement this function.
-       * @todo Document this function.
-       */
-      regex_iterator();
-      
-      /**
-       * Constructs a %regex_iterator...
-       * @param a  [IN] The start of a text range to search.
-       * @param b  [IN] One-past-the-end of the text range to search.
-       * @param re [IN] The regular expression to match.
-       * @param m  [IN] Policy flags for match rules.
-       * @todo Implement this function.
-       * @todo Document this function.
-       */
-      regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
-		     regex_constants::match_flag_type __m
-		     = regex_constants::match_default);
-
-      /**
-       * Copy constructs a %regex_iterator.
-       * @todo Implement this function.
-       * @todo Document this function.
-       */
-      regex_iterator(const regex_iterator& __rhs);
-      
-      /**
-       * @todo Implement this function.
-       * @todo Document this function.
-       */
-      regex_iterator&
-      operator=(const regex_iterator& __rhs);
-      
-      /**
-       * @todo Implement this function.
-       * @todo Document this function.
-       */
-      bool
-      operator==(const regex_iterator& __rhs);
-      
-      /**
-       * @todo Implement this function.
-       * @todo Document this function.
-       */
-      bool
-      operator!=(const regex_iterator& __rhs);
-      
-      /**
-       * @todo Implement this function.
-       * @todo Document this function.
-       */
-      const value_type&
-      operator*();
-      
-      /**
-       * @todo Implement this function.
-       * @todo Document this function.
-       */
-      const value_type*
-      operator->();
-      
-      /**
-       * @todo Implement this function.
-       * @todo Document this function.
-       */
-      regex_iterator&
-      operator++();
-      
-      /**
-       * @todo Implement this function.
-       * @todo Document this function.
-       */
-      regex_iterator
-      operator++(int);
-      
-    private:
-      // these members are shown for exposition only:
-      _Bi_iter                         begin;
-      _Bi_iter                         end;
-      const regex_type*                pregex;
-      regex_constants::match_flag_type flags;
-      match_results<_Bi_iter>          match;
-    };
-  
-  typedef regex_iterator<const char*>             cregex_iterator;
-  typedef regex_iterator<string::const_iterator>  sregex_iterator;
-#ifdef _GLIBCXX_USE_WCHAR_T
-  typedef regex_iterator<const wchar_t*>          wcregex_iterator;
-  typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
-#endif
-
-  // [7.12.2] Class template regex_token_iterator
-  /**
-   * Iterates over submatches in a range (or "splits" a text string).
-   *
-   * The purpose of this iterator is to enumerate all, or all specified,
-   * matches of a regular expression within a text range.  The dereferenced
-   * value of an iterator of this class is a std::tr1::sub_match object.
-   */
-  template<typename _Bi_iter,
-	   typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
-	   typename _Rx_traits = regex_traits<_Ch_type> >
-    class regex_token_iterator
-    {
-    public:
-      typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
-      typedef sub_match<_Bi_iter>               value_type;
-      typedef std::ptrdiff_t                    difference_type;
-      typedef const value_type*                 pointer;
-      typedef const value_type&                 reference;
-      typedef std::forward_iterator_tag         iterator_category;
-      
-    public:
-      /**
-       * @brief Default constructs a %regex_token_iterator.
-       * @todo Implement this function.
-       * 
-       * A default-constructed %regex_token_iterator is a singular iterator
-       * that will compare equal to the one-past-the-end value for any
-       * iterator of the same type.
-       */
-      regex_token_iterator();
-      
-      /**
-       * Constrcts a %regex_token_iterator...
-       * @param a          [IN] The start of the text to search.
-       * @param b          [IN] One-past-the-eend of the text to search.
-       * @param re         [IN] The regular expression to search for.
-       * @param submatch   [IN] Which submatch to return.  There are some
-       *                        special values for thsi parameter:
-       *                        - -1 each enumerated subexpression does NOT
-       *                          match the regular expression (aka field
-       *                          splitting)
-       *                        - 0 the entire string matching the
-       *                          subexpression is returned for each match
-       *                          within the text.
-       *                        - >0 enumerates only the indicated
-       *                          subexpression from a match within the text.
-       * @param m          [IN] Policy flags for match rules.
-       *
-       * @todo Implement this function.
-       * @todo Document this function.
-       */
-      regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
-			   int __submatch = 0,
-			   regex_constants::match_flag_type __m
-			   = regex_constants::match_default);
-
-      /**
-       * Constrcts a %regex_token_iterator...
-       * @param a          [IN] The start of the text to search.
-       * @param b          [IN] One-past-the-eend of the text to search.
-       * @param re         [IN] The regular expression to search for.
-       * @param submatches [IN] A list of subexpressions to return for each
-       *                        regular expression match within the text.
-       * @param m          [IN] Policy flags for match rules.
-       *
-       * @todo Implement this function.
-       * @todo Document this function.
-       */
-      regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
-			   const regex_type& __re,
-			   const std::vector<int>& __submatches,
-			   regex_constants::match_flag_type __m
-			     = regex_constants::match_default);
-
-      /**
-       * Constrcts a %regex_token_iterator...
-       * @param a          [IN] The start of the text to search.
-       * @param b          [IN] One-past-the-eend of the text to search.
-       * @param re         [IN] The regular expression to search for.
-       * @param submatches [IN] A list of subexpressions to return for each
-       *                        regular expression match within the text.
-       * @param m          [IN] Policy flags for match rules.
-       
-       * @todo Implement this function.
-       * @todo Document this function.
-       */
-      template<std::size_t _Nm>
-        regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
-			     const regex_type& __re,
-			     const int (&__submatches)[_Nm],
-			     regex_constants::match_flag_type __m
-			     = regex_constants::match_default);
-
-      /**
-       * @brief Copy constructs a %regex_token_iterator.
-       * @param rhs [IN] A %regex_token_iterator to copy.
-       * @todo Implement this function.
-       */
-      regex_token_iterator(const regex_token_iterator& __rhs);
-      
-      /**
-       * @brief Assigns a %regex_token_iterator to another.
-       * @param rhs [IN] A %regex_token_iterator to copy.
-       * @todo Implement this function.
-       */
-      regex_token_iterator&
-      operator=(const regex_token_iterator& __rhs);
-      
-      /**
-       * @brief Compares a %regex_token_iterator to another for equality.
-       * @todo Implement this function.
-       */
-      bool
-      operator==(const regex_token_iterator& __rhs);
-      
-      /**
-       * @brief Compares a %regex_token_iterator to another for inequality.
-       * @todo Implement this function.
-       */
-      bool
-      operator!=(const regex_token_iterator& __rhs);
-      
-      /**
-       * @brief Dereferences a %regex_token_iterator.
-       * @todo Implement this function.
-       */
-      const value_type&
-      operator*();
-      
-      /**
-       * @brief Selects a %regex_token_iterator member.
-       * @todo Implement this function.
-       */
-      const value_type*
-      operator->();
-      
-      /**
-       * @brief Increments a %regex_token_iterator.
-       * @todo Implement this function.
-       */
-      regex_token_iterator&
-      operator++();
-      
-      /**
-       * @brief Postincrements a %regex_token_iterator.
-       * @todo Implement this function.
-       */
-      regex_token_iterator
-      operator++(int);
-      
-    private: // data members for exposition only:
-      typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> position_iterator;
-
-      position_iterator __position;
-      const value_type* __result;
-      value_type        __suffix;
-      std::size_t       __n;
-      std::vector<int>  __subs;
-    };
-
-  typedef regex_token_iterator<const char*>             cregex_token_iterator;
-  typedef regex_token_iterator<string::const_iterator>  sregex_token_iterator;
-#ifdef _GLIBCXX_USE_WCHAR_T
-  typedef regex_token_iterator<const wchar_t*>          wcregex_token_iterator;
-  typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/regex>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/regex>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
 #endif
-  
-  /** @} */ // group tr1_regex
-  
-_GLIBCXX_END_NAMESPACE
-}
 
-#endif // _TR1_REGEX
+#endif // _GLIBCXX_TR1_REGEX
diff --git a/libstdc++-v3/include/tr1/riemann_zeta.tcc b/libstdc++-v3/include/tr1/riemann_zeta.tcc
index 598d73e..40277c0 100644
--- a/libstdc++-v3/include/tr1/riemann_zeta.tcc
+++ b/libstdc++-v3/include/tr1/riemann_zeta.tcc
@@ -45,14 +45,15 @@
 //   (3) Gamma, Exploring Euler's Constant, Julian Havil,
 //       Princeton, 2003.
 
-#ifndef _TR1_RIEMANN_ZETA_TCC
-#define _TR1_RIEMANN_ZETA_TCC 1
+#ifndef _GLIBCXX_TR1_RIEMANN_ZETA_TCC
+#define _GLIBCXX_TR1_RIEMANN_ZETA_TCC 1
 
 #include "special_function_util.h"
 
 namespace std
 {
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
 
   // [5.2] Special functions
 
@@ -175,7 +176,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
       if (__s < _Tp(0))
         {
 #if _GLIBCXX_USE_C99_MATH_TR1
-          if (std::_GLIBCXX_TR1::fmod(__s,_Tp(2)) == _Tp(0))
+          if (std::tr1::fmod(__s,_Tp(2)) == _Tp(0))
             return _Tp(0);
           else
 #endif
@@ -185,7 +186,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
                      * __numeric_constants<_Tp>::__pi(), __s)
                      * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
 #if _GLIBCXX_USE_C99_MATH_TR1
-                     * std::exp(std::_GLIBCXX_TR1::lgamma(_Tp(1) - __s))
+                     * std::exp(std::tr1::lgamma(_Tp(1) - __s))
 #else
                      * std::exp(__log_gamma(_Tp(1) - __s))
 #endif
@@ -204,9 +205,9 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
           for (unsigned int __j = 0; __j <= __i; ++__j)
             {
 #if _GLIBCXX_USE_C99_MATH_TR1
-              _Tp __bincoeff =  std::_GLIBCXX_TR1::lgamma(_Tp(1 + __i))
-                              - std::_GLIBCXX_TR1::lgamma(_Tp(1 + __j))
-                              - std::_GLIBCXX_TR1::lgamma(_Tp(1 + __i - __j));
+              _Tp __bincoeff =  std::tr1::lgamma(_Tp(1 + __i))
+                              - std::tr1::lgamma(_Tp(1 + __j))
+                              - std::tr1::lgamma(_Tp(1 + __i - __j));
 #else
               _Tp __bincoeff =  __log_gamma(_Tp(1 + __i))
                               - __log_gamma(_Tp(1 + __j))
@@ -309,7 +310,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
           __zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s)
                  * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
 #if _GLIBCXX_USE_C99_MATH_TR1
-                 * std::exp(std::_GLIBCXX_TR1::lgamma(_Tp(1) - __s))
+                 * std::exp(std::tr1::lgamma(_Tp(1) - __s))
 #else
                  * std::exp(__log_gamma(_Tp(1) - __s))
 #endif
@@ -332,7 +333,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
                                 * __numeric_constants<_Tp>::__pi(), __s)
                          * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
 #if _GLIBCXX_USE_C99_MATH_TR1
-                             * std::_GLIBCXX_TR1::tgamma(_Tp(1) - __s)
+                             * std::tr1::tgamma(_Tp(1) - __s)
 #else
                              * std::exp(__log_gamma(_Tp(1) - __s))
 #endif
@@ -387,9 +388,9 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
           for (unsigned int __j = 0; __j <= __i; ++__j)
             {
 #if _GLIBCXX_USE_C99_MATH_TR1
-              _Tp __bincoeff =  std::_GLIBCXX_TR1::lgamma(_Tp(1 + __i))
-                              - std::_GLIBCXX_TR1::lgamma(_Tp(1 + __j))
-                              - std::_GLIBCXX_TR1::lgamma(_Tp(1 + __i - __j));
+              _Tp __bincoeff =  std::tr1::lgamma(_Tp(1 + __i))
+                              - std::tr1::lgamma(_Tp(1 + __j))
+                              - std::tr1::lgamma(_Tp(1 + __i - __j));
 #else
               _Tp __bincoeff =  __log_gamma(_Tp(1 + __i))
                               - __log_gamma(_Tp(1 + __j))
@@ -443,7 +444,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 
   /* @} */ // group tr1_math_spec_func
 
-_GLIBCXX_END_NAMESPACE
+}
 }
 
-#endif // _TR1_RIEMANN_ZETA_TCC
+#endif // _GLIBCXX_TR1_RIEMANN_ZETA_TCC
diff --git a/libstdc++-v3/include/tr1/special_function_util.h b/libstdc++-v3/include/tr1/special_function_util.h
index ac55165..2f33c39 100644
--- a/libstdc++-v3/include/tr1/special_function_util.h
+++ b/libstdc++-v3/include/tr1/special_function_util.h
@@ -39,13 +39,14 @@
 
 // Written by Edward Smith-Rowland based on numerous mathematics books.
 
-#ifndef _TR1_SPECIAL_FUNCTION_UTIL_H
-#define _TR1_SPECIAL_FUNCTION_UTIL_H 1
+#ifndef _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H
+#define _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H 1
 
 // namespace std::tr1
 namespace std
 {
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
 
   namespace __detail
   {
@@ -148,8 +149,8 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 
   } // namespace __detail
 
-_GLIBCXX_END_NAMESPACE
+}
 }
 
-#endif // _TR1_SPECIAL_FUNCTION_UTIL_H
+#endif // _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H
 
diff --git a/libstdc++-v3/include/tr1/stdlib.h b/libstdc++-v3/include/tr1/stdlib.h
index 0075cc7..50c5e21 100644
--- a/libstdc++-v3/include/tr1/stdlib.h
+++ b/libstdc++-v3/include/tr1/stdlib.h
@@ -31,8 +31,8 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_STDLIB_H
-#define _TR1_STDLIB_H 1
+#ifndef _GLIBCXX_TR1_STDLIB_H
+#define _GLIBCXX_TR1_STDLIB_H 1
 
 #include <tr1/cstdlib>
 
@@ -40,17 +40,18 @@
 
 #if _GLIBCXX_USE_C99
 
-using std::_GLIBCXX_TR1::atoll;
-using std::_GLIBCXX_TR1::strtoll;
-using std::_GLIBCXX_TR1::strtoull;
+using std::tr1::atoll;
+using std::tr1::strtoll;
+using std::tr1::strtoull;
 
-using std::_GLIBCXX_TR1::abs;
+using std::tr1::abs;
 #if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
-using std::_GLIBCXX_TR1::div;
+using std::tr1::div;
 #endif
 
 #endif
 
 #endif
 
-#endif
+#endif // _GLIBCXX_TR1_STDLIB_H
+
diff --git a/libstdc++-v3/include/tr1/tgmath.h b/libstdc++-v3/include/tr1/tgmath.h
index 90c8a63..1bf9321 100644
--- a/libstdc++-v3/include/tr1/tgmath.h
+++ b/libstdc++-v3/include/tr1/tgmath.h
@@ -1,6 +1,6 @@
 // TR1 tgmath.h -*- C++ -*-
 
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -31,9 +31,9 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_TGMATH_H
-#define _TR1_TGMATH_H 1
+#ifndef _GLIBCXX_TR1_TGMATH_H
+#define _GLIBCXX_TR1_TGMATH_H 1
 
 #include <tr1/ctgmath>
 
-#endif
+#endif // _GLIBCXX_TR1_TGMATH_H
diff --git a/libstdc++-v3/include/tr1/tuple b/libstdc++-v3/include/tr1/tuple
index 7beef19..0c7ed3f 100644
--- a/libstdc++-v3/include/tr1/tuple
+++ b/libstdc++-v3/include/tr1/tuple
@@ -34,405 +34,29 @@
 // Chris Jefferson <chris@bubblescope.net>
 // Variadic Templates support by Douglas Gregor <doug.gregor@gmail.com>
 
-#ifndef _TR1_TUPLE
-#define _TR1_TUPLE 1
+#ifndef _GLIBCXX_TR1_TUPLE
+#define _GLIBCXX_TR1_TUPLE 1
 
 #pragma GCC system_header
 
-#include <utility>
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-  template<typename _Tp>
-    class reference_wrapper;
-
-  // Adds a const reference to a non-reference type.
-  template<typename _Tp>
-    struct __add_c_ref
-    { typedef const _Tp& type; };
-
-  template<typename _Tp>
-    struct __add_c_ref<_Tp&>
-    { typedef _Tp& type; };
-
-  // Adds a reference to a non-reference type.
-  template<typename _Tp>
-    struct __add_ref
-    { typedef _Tp& type; };
-
-  template<typename _Tp>
-    struct __add_ref<_Tp&>
-    { typedef _Tp& type; };
-
-  /**
-   * @if maint
-   * Contains the actual implementation of the @c tuple template, stored
-   * as a recursive inheritance hierarchy from the first element (most
-   * derived class) to the last (least derived class). The @c Idx
-   * parameter gives the 0-based index of the element stored at this
-   * point in the hierarchy; we use it to implement a constant-time
-   * get() operation.
-   * @endif
-   */
-  template<int _Idx, typename... _Elements>
-    struct _Tuple_impl; 
-
-  /**
-   * @if maint
-   * Zero-element tuple implementation. This is the basis case for the 
-   * inheritance recursion.
-   * @endif maint
-   */
-  template<int _Idx>
-    struct _Tuple_impl<_Idx> { };
-
-  /**
-   * @if maint
-   * Recursive tuple implementation. Here we store the @c Head element
-   * and derive from a @c Tuple_impl containing the remaining elements
-   * (which contains the @c Tail).
-   * @endif
-   */
-  template<int _Idx, typename _Head, typename... _Tail>
-    struct _Tuple_impl<_Idx, _Head, _Tail...>
-    : public _Tuple_impl<_Idx + 1, _Tail...>
-    {
-      typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
-      
-      _Head _M_head;
-      
-      _Inherited&       _M_tail()       { return *this; }
-      const _Inherited& _M_tail() const { return *this; }
-      
-      _Tuple_impl() : _Inherited(), _M_head() { }
-      
-      explicit 
-      _Tuple_impl(typename __add_c_ref<_Head>::type __head,
-		  typename __add_c_ref<_Tail>::type... __tail)
-      : _Inherited(__tail...), _M_head(__head) { }
-
-      template<typename... _UElements>
-      _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
-      : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
-
-      _Tuple_impl(const _Tuple_impl& __in)
-      : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
-     
-      template<typename... _UElements>
-        _Tuple_impl&
-        operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
-        {
-	  _M_head = __in._M_head;
-	  _M_tail() = __in._M_tail();
-	  return *this;
-	}
-
-      _Tuple_impl&
-      operator=(const _Tuple_impl& __in)
-      {
-	_M_head = __in._M_head;
-	_M_tail() = __in._M_tail();
-	return *this;
-      }
-    };
-
-  template<typename... _Elements> 
-    class tuple : public _Tuple_impl<0, _Elements...>
-    {
-      typedef _Tuple_impl<0, _Elements...> _Inherited;
-
-    public:
-      tuple() : _Inherited() { }
-
-      explicit
-      tuple(typename __add_c_ref<_Elements>::type... __elements)
-      : _Inherited(__elements...) { }
-
-      template<typename... _UElements>
-        tuple(const tuple<_UElements...>& __in)
-	: _Inherited(__in) { }
-
-      tuple(const tuple& __in)
-      : _Inherited(__in) { }
-
-      template<typename... _UElements>
-        tuple&
-        operator=(const tuple<_UElements...>& __in)
-        {
-	  static_cast<_Inherited&>(*this) = __in;
-	  return *this;
-	}
-
-      tuple&
-      operator=(const tuple& __in)
-      {
-	static_cast<_Inherited&>(*this) = __in;
-	return *this;
-      }
-    };
-
-  template<> class tuple<> { };
-
-  // 2-element tuple, with construction and assignment from a pair.
-  template<typename _T1, typename _T2>
-    class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
-    {
-      typedef _Tuple_impl<0, _T1, _T2> _Inherited;
-
-    public:
-      tuple() : _Inherited() { }
-
-      explicit
-      tuple(typename __add_c_ref<_T1>::type __a1,
-	    typename __add_c_ref<_T2>::type __a2)
-      : _Inherited(__a1, __a2) { }
-
-      template<typename _U1, typename _U2>
-        tuple(const tuple<_U1, _U2>& __in)
-	: _Inherited(__in) { }
-
-      tuple(const tuple& __in)
-      : _Inherited(__in) { }
-
-      template<typename _U1, typename _U2>
-        tuple(const pair<_U1, _U2>& __in)
-	: _Inherited(_Tuple_impl<0, 
-		     typename __add_c_ref<_U1>::type,
-		     typename __add_c_ref<_U2>::type>(__in.first, 
-						      __in.second))
-        { }
-  
-      template<typename _U1, typename _U2>
-        tuple&
-        operator=(const tuple<_U1, _U2>& __in)
-        {
-	  static_cast<_Inherited&>(*this) = __in;
-	  return *this;
-	}
-
-      tuple&
-      operator=(const tuple& __in)
-      {
-	static_cast<_Inherited&>(*this) = __in;
-	return *this;
-      }
-
-      template<typename _U1, typename _U2>
-        tuple&
-        operator=(const pair<_U1, _U2>& __in)
-        {
-	  this->_M_head = __in.first;
-	  this->_M_tail()._M_head = __in.second;
-	  return *this;
-	}
-    };
-
-  
-  /// Gives the type of the ith element of a given tuple type.
-  template<int __i, typename _Tp>
-    struct tuple_element;
-
-  /**
-   * @if maint
-   * Recursive case for tuple_element: strip off the first element in
-   * the tuple and retrieve the (i-1)th element of the remaining tuple.
-   * @endif
-   */
-  template<int __i, typename _Head, typename... _Tail>
-    struct tuple_element<__i, tuple<_Head, _Tail...> >
-    : tuple_element<__i - 1, tuple<_Tail...> > { };
-
-  /**
-   * @if maint
-   * Basis case for tuple_element: The first element is the one we're seeking.
-   * @endif
-   */
-  template<typename _Head, typename... _Tail>
-    struct tuple_element<0, tuple<_Head, _Tail...> >
-    {
-      typedef _Head type;
-    };
-
-  /// Finds the size of a given tuple type.
-  template<typename _Tp>
-    struct tuple_size;
-
-  /// @brief class tuple_size
-  template<typename... _Elements>
-    struct tuple_size<tuple<_Elements...> >
-    {
-      static const int value = sizeof...(_Elements);
-    };
-
-  template<typename... _Elements>
-    const int tuple_size<tuple<_Elements...> >::value;
-
-  template<int __i, typename _Head, typename... _Tail>
-    inline typename __add_ref<_Head>::type
-    __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t)
-    {
-      return __t._M_head;
-    }
-
-  template<int __i, typename _Head, typename... _Tail>
-    inline typename __add_c_ref<_Head>::type
-    __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t)
-    {
-      return __t._M_head;
-    }
-
-  // Return a reference (const reference) to the ith element of a tuple.
-  // Any const or non-const ref elements are returned with their original type.
-  template<int __i, typename... _Elements>
-    inline typename __add_ref<
-                      typename tuple_element<__i, tuple<_Elements...> >::type
-                    >::type
-    get(tuple<_Elements...>& __t)
-    { 
-      return __get_helper<__i>(__t); 
-    }
-
-  template<int __i, typename... _Elements>
-    inline typename __add_c_ref<
-                      typename tuple_element<__i, tuple<_Elements...> >::type
-                    >::type
-    get(const tuple<_Elements...>& __t)
-    {
-      return __get_helper<__i>(__t);
-    }
-
-  // This class helps construct the various comparison operations on tuples
-  template<int __check_equal_size, int __i, int __j,
-	   typename _Tp, typename _Up>
-    struct __tuple_compare;
-
-  template<int __i, int __j, typename _Tp, typename _Up>
-    struct __tuple_compare<0, __i, __j, _Tp, _Up>
-    {
-      static bool __eq(const _Tp& __t, const _Up& __u)
-      {
-	return (get<__i>(__t) == get<__i>(__u) &&
-		__tuple_compare<0, __i+1, __j, _Tp, _Up>::__eq(__t, __u));
-      }
-     
-      static bool __less(const _Tp& __t, const _Up& __u)
-      {
-	return ((get<__i>(__t) < get<__i>(__u))
-		|| !(get<__i>(__u) < get<__i>(__t)) &&
-		__tuple_compare<0, __i+1, __j, _Tp, _Up>::__less(__t, __u));
-      }
-    };
-
-  template<int __i, typename _Tp, typename _Up>
-    struct __tuple_compare<0, __i, __i, _Tp, _Up>
-    {
-      static bool __eq(const _Tp&, const _Up&)
-      { return true; }
-     
-      static bool __less(const _Tp&, const _Up&)
-      { return false; }
-    };
-
-  template<typename... _TElements, typename... _UElements>
-    bool
-    operator==(const tuple<_TElements...>& __t,
-	       const tuple<_UElements...>& __u)
-    {
-      typedef tuple<_TElements...> _Tp;
-      typedef tuple<_UElements...> _Up;
-      return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Tp>::value,
-	      0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u));
-    }
-
-  template<typename... _TElements, typename... _UElements>
-    bool
-    operator<(const tuple<_TElements...>& __t,
-	      const tuple<_UElements...>& __u)
-    {
-      typedef tuple<_TElements...> _Tp;
-      typedef tuple<_UElements...> _Up;
-      return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Tp>::value,
-	      0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u));
-    }
-
-  template<typename... _TElements, typename... _UElements>
-    bool
-    operator!=(const tuple<_TElements...>& __t,
-	       const tuple<_UElements...>& __u)
-    { return !(__t == __u); }
-
-  template<typename... _TElements, typename... _UElements>
-    bool
-    operator>(const tuple<_TElements...>& __t,
-	      const tuple<_UElements...>& __u)
-    { return __u < __t; }
-
-  template<typename... _TElements, typename... _UElements>
-    bool
-    operator<=(const tuple<_TElements...>& __t,
-	       const tuple<_UElements...>& __u)
-    { return !(__u < __t); }
-
-  template<typename... _TElements, typename... _UElements>
-    bool
-    operator>=(const tuple<_TElements...>& __t,
-	       const tuple<_UElements...>& __u)
-    { return !(__t < __u); }
-
-  // Helper which adds a reference to a type when given a reference_wrapper
-  template<typename _Tp>
-    struct __strip_reference_wrapper
-    {
-      typedef _Tp __type;
-    };
-
-  template<typename _Tp>
-    struct __strip_reference_wrapper<reference_wrapper<_Tp> >
-    {
-      typedef _Tp& __type;
-    };
-
-  template<typename _Tp>
-    struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
-    {
-      typedef _Tp& __type;
-    };
-
-  template<typename... _Elements>
-    inline tuple<typename __strip_reference_wrapper<_Elements>::__type...>
-    make_tuple(_Elements... __args)
-    {
-      typedef tuple<typename __strip_reference_wrapper<_Elements>::__type...>
-        __result_type;
-      return __result_type(__args...);
-    }
-
-  template<typename... _Elements>
-    inline tuple<_Elements&...>
-    tie(_Elements&... __args)
-    {
-      return tuple<_Elements&...>(__args...);
-    }
-
-  // A class (and instance) which can be used in 'tie' when an element
-  // of a tuple is not required
-  struct _Swallow_assign
-  {
-    template<class _Tp>
-      _Swallow_assign&
-      operator=(const _Tp&)
-      { return *this; }
-  };
-
-  // TODO: Put this in some kind of shared file.
-  namespace
-  {
-    _Swallow_assign ignore;
-  }; // anonymous namespace
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
 
-_GLIBCXX_END_NAMESPACE
-}
+#include <utility>
 
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/tuple>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/tuple>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
 #endif
+
+#endif // _GLIBCXX_TR1_TUPLE
diff --git a/libstdc++-v3/include/tr1/type_traits b/libstdc++-v3/include/tr1/type_traits
index 41edc3a..709cbd9 100644
--- a/libstdc++-v3/include/tr1/type_traits
+++ b/libstdc++-v3/include/tr1/type_traits
@@ -31,26 +31,35 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_TYPE_TRAITS
-#define _TR1_TYPE_TRAITS 1
+#ifndef _GLIBCXX_TR1_TYPE_TRAITS
+#define _GLIBCXX_TR1_TYPE_TRAITS 1
 
 #pragma GCC system_header
 
-#include <bits/c++config.h>
-#include <tr1/type_traitsfwd.h>
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
+
+#include <cstddef>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/type_traits>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/type_traits>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
+#endif
 
-// namespace std::tr1
 namespace std
 {
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-  // For use in __is_convertible_simple.
-  struct __sfinae_types
-  {
-    typedef char __one;
-    typedef struct { char __arr[2]; } __two;
-  };
-
+namespace tr1
+{
 #define _DEFINE_SPEC_BODY(_Value)                                    \
     : public integral_constant<bool, _Value> { };
 
@@ -59,193 +68,29 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
     struct _Spec                                                     \
     _DEFINE_SPEC_BODY(_Value)
 
-#define _DEFINE_SPEC_1_HELPER(_Spec, _Value)                         \
-  template<typename _Tp>                                             \
-    struct _Spec                                                     \
-    _DEFINE_SPEC_BODY(_Value)
-      
-#define _DEFINE_SPEC_2_HELPER(_Spec, _Value)                         \
-  template<typename _Tp, typename _Cp>                               \
-    struct _Spec                                                     \
-    _DEFINE_SPEC_BODY(_Value)
-
 #define _DEFINE_SPEC(_Order, _Trait, _Type, _Value)                  \
   _DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type>, _Value)              \
   _DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type const>, _Value)        \
   _DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type volatile>, _Value)     \
   _DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type const volatile>, _Value)
 
-  /// @brief  helper classes [4.3].
-  template<typename _Tp, _Tp __v>
-    struct integral_constant
-    {
-      static const _Tp                      value = __v;
-      typedef _Tp                           value_type;
-      typedef integral_constant<_Tp, __v>   type;
-    };
-  typedef integral_constant<bool, true>     true_type;
-  typedef integral_constant<bool, false>    false_type;
-
-  template<typename _Tp, _Tp __v>
-    const _Tp integral_constant<_Tp, __v>::value;
-
-  /// @brief  primary type categories [4.5.1].
   template<typename>
-    struct is_void
-    : public false_type { };
-  _DEFINE_SPEC(0, is_void, void, true)
-
-  template<typename>
-    struct is_integral
-    : public false_type { };
-  _DEFINE_SPEC(0, is_integral, bool, true)
-  _DEFINE_SPEC(0, is_integral, char, true)
-  _DEFINE_SPEC(0, is_integral, signed char, true)
-  _DEFINE_SPEC(0, is_integral, unsigned char, true)
-#ifdef _GLIBCXX_USE_WCHAR_T
-  _DEFINE_SPEC(0, is_integral, wchar_t, true)
-#endif
-  _DEFINE_SPEC(0, is_integral, short, true)
-  _DEFINE_SPEC(0, is_integral, unsigned short, true)
-  _DEFINE_SPEC(0, is_integral, int, true)
-  _DEFINE_SPEC(0, is_integral, unsigned int, true)
-  _DEFINE_SPEC(0, is_integral, long, true)
-  _DEFINE_SPEC(0, is_integral, unsigned long, true)
-  _DEFINE_SPEC(0, is_integral, long long, true)
-  _DEFINE_SPEC(0, is_integral, unsigned long long, true)
-
-  template<typename>
-    struct is_floating_point
-    : public false_type { };
-  _DEFINE_SPEC(0, is_floating_point, float, true)
-  _DEFINE_SPEC(0, is_floating_point, double, true)
-  _DEFINE_SPEC(0, is_floating_point, long double, true)
-
-  template<typename>
-    struct is_array
-    : public false_type { };
-
-  template<typename _Tp, std::size_t _Size>
-    struct is_array<_Tp[_Size]>
-    : public true_type { };
-
-  template<typename _Tp>
-    struct is_array<_Tp[]>
-    : public true_type { };
-
-  template<typename>
-    struct is_pointer
-    : public false_type { };
-  _DEFINE_SPEC(1, is_pointer, _Tp*, true)
- 
-  template<typename>
-    struct is_reference
-    : public false_type { };
-
-  template<typename _Tp>
-    struct is_reference<_Tp&>
-    : public true_type { };
-
-  template<typename>
-    struct is_member_object_pointer
-    : public false_type { };
-  _DEFINE_SPEC(2, is_member_object_pointer, _Tp _Cp::*,
-	       !is_function<_Tp>::value)
-
-  template<typename>
-    struct is_member_function_pointer
-    : public false_type { };
-  _DEFINE_SPEC(2, is_member_function_pointer, _Tp _Cp::*,
-	       is_function<_Tp>::value)
-
-  template<typename _Tp>
-    struct is_enum
-    : public integral_constant<bool, __is_enum(_Tp)>
-    { };
-
-  template<typename _Tp>
-    struct is_union
-    : public integral_constant<bool, __is_union(_Tp)>
-    { };
-
-  template<typename _Tp>
-    struct is_class
-    : public integral_constant<bool, __is_class(_Tp)>
-    { };
-
-  template<typename>
-    struct __is_function_helper
-    : public false_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct __is_function_helper<_Res(_ArgTypes...)>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct __is_function_helper<_Res(_ArgTypes......)>
-    : public true_type { };
-
-  template<typename _Tp>
-    struct is_function
-    : public integral_constant<bool, (__is_function_helper<typename
-				      remove_cv<_Tp>::type>::value)>
-    { };
-
-  /// @brief  composite type traits [4.5.2].
-  template<typename _Tp>
-    struct is_arithmetic
-    : public integral_constant<bool, (is_integral<_Tp>::value
-				      || is_floating_point<_Tp>::value)>
-    { };
-
-  template<typename _Tp>
-    struct is_fundamental
-    : public integral_constant<bool, (is_arithmetic<_Tp>::value
-				      || is_void<_Tp>::value)>
-    { };
-
-  template<typename _Tp>
-    struct is_object
-    : public integral_constant<bool, !(is_function<_Tp>::value
-				       || is_reference<_Tp>::value
-				       || is_void<_Tp>::value)>
-    { };
-
-  template<typename _Tp>
-    struct is_scalar
-    : public integral_constant<bool, (is_arithmetic<_Tp>::value
-				      || is_enum<_Tp>::value
-				      || is_pointer<_Tp>::value
-				      || is_member_pointer<_Tp>::value)>
-    { };
-
-  template<typename _Tp>
-    struct is_compound
-    : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
-
-  template<typename _Tp>
-    struct is_member_pointer
-    : public integral_constant<bool,
-			       (is_member_object_pointer<_Tp>::value
-				|| is_member_function_pointer<_Tp>::value)>
-    { };
-
-  /// @brief  type properties [4.5.3].
-  template<typename>
-    struct is_const
+    struct is_signed
     : public false_type { };
+  _DEFINE_SPEC(0, is_signed, signed char, true)
+  _DEFINE_SPEC(0, is_signed, short, true)
+  _DEFINE_SPEC(0, is_signed, int, true)
+  _DEFINE_SPEC(0, is_signed, long, true)
+  _DEFINE_SPEC(0, is_signed, long long, true)
 
-  template<typename _Tp>
-    struct is_const<_Tp const>
-    : public true_type { };
-  
   template<typename>
-    struct is_volatile
+    struct is_unsigned
     : public false_type { };
-
-  template<typename _Tp>
-    struct is_volatile<_Tp volatile>
-    : public true_type { };
+  _DEFINE_SPEC(0, is_unsigned, unsigned char, true)
+  _DEFINE_SPEC(0, is_unsigned, unsigned short, true)
+  _DEFINE_SPEC(0, is_unsigned, unsigned int, true)
+  _DEFINE_SPEC(0, is_unsigned, unsigned long, true)
+  _DEFINE_SPEC(0, is_unsigned, unsigned long long, true)
 
   template<typename _Tp>
     struct is_pod
@@ -253,113 +98,39 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
     { };
 
   template<typename _Tp>
-    struct is_empty
-    : public integral_constant<bool, __is_empty(_Tp)>
-    { };
-
-  template<typename _Tp>
-    struct is_polymorphic
-    : public integral_constant<bool, __is_polymorphic(_Tp)>
-    { };
-
-  template<typename _Tp>
-    struct is_abstract
-    : public integral_constant<bool, __is_abstract(_Tp)>
-    { };
-
-  template<typename _Tp>
     struct has_trivial_constructor
-    : public integral_constant<bool, is_pod<_Tp>::value> { };
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
 
   template<typename _Tp>
     struct has_trivial_copy
-    : public integral_constant<bool, is_pod<_Tp>::value> { };
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
 
   template<typename _Tp>
     struct has_trivial_assign
-    : public integral_constant<bool, is_pod<_Tp>::value> { };
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
 
   template<typename _Tp>
     struct has_trivial_destructor
-    : public integral_constant<bool, is_pod<_Tp>::value> { };
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
 
   template<typename _Tp>
     struct has_nothrow_constructor
-    : public integral_constant<bool, is_pod<_Tp>::value> { };
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
 
   template<typename _Tp>
     struct has_nothrow_copy
-    : public integral_constant<bool, is_pod<_Tp>::value> { };
-
-  template<typename _Tp>
-    struct has_nothrow_assign
-    : public integral_constant<bool, is_pod<_Tp>::value> { };
-
-  template<typename _Tp>
-    struct has_virtual_destructor
-    : public integral_constant<bool, __has_virtual_destructor(_Tp)>
+    : public integral_constant<bool, is_pod<_Tp>::value>
     { };
 
-  template<typename>
-    struct is_signed
-    : public false_type { };
-  _DEFINE_SPEC(0, is_signed, signed char, true)
-  _DEFINE_SPEC(0, is_signed, short, true)
-  _DEFINE_SPEC(0, is_signed, int, true)
-  _DEFINE_SPEC(0, is_signed, long, true)
-  _DEFINE_SPEC(0, is_signed, long long, true)
-
-  template<typename>
-    struct is_unsigned
-    : public false_type { };
-  _DEFINE_SPEC(0, is_unsigned, unsigned char, true)
-  _DEFINE_SPEC(0, is_unsigned, unsigned short, true)
-  _DEFINE_SPEC(0, is_unsigned, unsigned int, true)
-  _DEFINE_SPEC(0, is_unsigned, unsigned long, true)
-  _DEFINE_SPEC(0, is_unsigned, unsigned long long, true)
-
   template<typename _Tp>
-    struct alignment_of
-    : public integral_constant<std::size_t, __alignof__(_Tp)> { };
-  
-  template<typename>
-    struct rank
-    : public integral_constant<std::size_t, 0> { };
-   
-  template<typename _Tp, std::size_t _Size>
-    struct rank<_Tp[_Size]>
-    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
-
-  template<typename _Tp>
-    struct rank<_Tp[]>
-    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
-   
-  template<typename, unsigned>
-    struct extent
-    : public integral_constant<std::size_t, 0> { };
-  
-  template<typename _Tp, unsigned _Uint, std::size_t _Size>
-    struct extent<_Tp[_Size], _Uint>
-    : public integral_constant<std::size_t,
-			       _Uint == 0 ? _Size : extent<_Tp,
-							   _Uint - 1>::value>
-    { };
-
-  template<typename _Tp, unsigned _Uint>
-    struct extent<_Tp[], _Uint>
-    : public integral_constant<std::size_t,
-			       _Uint == 0 ? 0 : extent<_Tp,
-						       _Uint - 1>::value>
+    struct has_nothrow_assign
+    : public integral_constant<bool, is_pod<_Tp>::value>
     { };
-  
-  /// @brief  relationships between types [4.6].
-  template<typename, typename>
-    struct is_same
-    : public false_type { };
-
-  template<typename _Tp>
-    struct is_same<_Tp, _Tp>
-    : public true_type { };
 
   template<typename _Base, typename _Derived>
     struct __is_base_of_helper
@@ -427,188 +198,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 			       __is_convertible_helper<_From, _To>::__value>
     { };
 
-  /// @brief  const-volatile modifications [4.7.1].
-  template<typename _Tp>
-    struct remove_const
-    { typedef _Tp     type; };
-
-  template<typename _Tp>
-    struct remove_const<_Tp const>
-    { typedef _Tp     type; };
-  
-  template<typename _Tp>
-    struct remove_volatile
-    { typedef _Tp     type; };
-
-  template<typename _Tp>
-    struct remove_volatile<_Tp volatile>
-    { typedef _Tp     type; };
-  
-  template<typename _Tp>
-    struct remove_cv
-    {
-      typedef typename
-      remove_const<typename remove_volatile<_Tp>::type>::type     type;
-    };
-  
-  template<typename _Tp>
-    struct add_const
-    { typedef _Tp const     type; };
-   
-  template<typename _Tp>
-    struct add_volatile
-    { typedef _Tp volatile     type; };
-  
-  template<typename _Tp>
-    struct add_cv
-    {
-      typedef typename
-      add_const<typename add_volatile<_Tp>::type>::type     type;
-    };
-
-  /// @brief  reference modifications [4.7.2].
-  template<typename _Tp>
-    struct remove_reference
-    { typedef _Tp     type; };
-
-  template<typename _Tp>
-    struct remove_reference<_Tp&>
-    { typedef _Tp     type; };
-
-  // NB: Careful with reference to void.
-  template<typename _Tp, bool = (is_void<_Tp>::value
-				 || is_reference<_Tp>::value)>
-    struct __add_reference_helper
-    { typedef _Tp&    type; };
-
-  template<typename _Tp>
-    struct __add_reference_helper<_Tp, true>
-    { typedef _Tp     type; };
-
-  template<typename _Tp>
-    struct add_reference
-    : public __add_reference_helper<_Tp>
-    { };
-
-  /// @brief  array modifications [4.7.3].
-  template<typename _Tp>
-    struct remove_extent
-    { typedef _Tp     type; };
-
-  template<typename _Tp, std::size_t _Size>
-    struct remove_extent<_Tp[_Size]>
-    { typedef _Tp     type; };
-
-  template<typename _Tp>
-    struct remove_extent<_Tp[]>
-    { typedef _Tp     type; };
-
-  template<typename _Tp>
-    struct remove_all_extents
-    { typedef _Tp     type; };
-
-  template<typename _Tp, std::size_t _Size>
-    struct remove_all_extents<_Tp[_Size]>
-    { typedef typename remove_all_extents<_Tp>::type     type; };
-
-  template<typename _Tp>
-    struct remove_all_extents<_Tp[]>
-    { typedef typename remove_all_extents<_Tp>::type     type; };
-
-  /// @brief  pointer modifications [4.7.4].
-#undef _DEFINE_SPEC_BODY
-#define _DEFINE_SPEC_BODY(_Value)      \
-    { typedef _Tp     type; };
-
-  template<typename _Tp>
-    struct remove_pointer
-    { typedef _Tp     type; };
-  _DEFINE_SPEC(1, remove_pointer, _Tp*, false)
-  
-  template<typename _Tp>
-    struct add_pointer
-    { typedef typename remove_reference<_Tp>::type*     type; };
-
-  /// @brief  other transformations [4.8].
-  
-  // Due to c++/19163 and c++/17743, for the time being we cannot use
-  // the correct, neat implementation :-(
-  // 
-  // template<std::size_t _Len, std::size_t _Align>
-  //   struct aligned_storage
-  //   { typedef char type[_Len] __attribute__((__aligned__(_Align))); }
-  //
-  // Temporary workaround, useful for Align up to 32:
-  template<std::size_t, std::size_t>
-    struct aligned_storage { };
-
-  template<std::size_t _Len>
-    struct aligned_storage<_Len, 1>
-    {
-      union type
-      {
-	unsigned char __data[_Len];
-	char __align __attribute__((__aligned__(1)));
-      };
-    };
-
-  template<std::size_t _Len>
-    struct aligned_storage<_Len, 2>
-    {
-      union type
-      {
-	unsigned char __data[_Len];
-	char __align __attribute__((__aligned__(2)));
-      };
-    };
-
-  template<std::size_t _Len>
-    struct aligned_storage<_Len, 4>
-    {
-      union type
-      {
-	unsigned char __data[_Len];
-	char __align __attribute__((__aligned__(4)));
-      };
-    };
-
-  template<std::size_t _Len>
-    struct aligned_storage<_Len, 8>
-    {
-      union type
-      {
-	unsigned char __data[_Len];
-	char __align __attribute__((__aligned__(8)));
-      };
-    };
-
-  template<std::size_t _Len>
-    struct aligned_storage<_Len, 16>
-    {
-      union type
-      {
-	unsigned char __data[_Len];
-	char __align __attribute__((__aligned__(16)));
-      };
-    };
-  
-  template<std::size_t _Len>
-    struct aligned_storage<_Len, 32>
-    {
-      union type
-      {
-	unsigned char __data[_Len];
-	char __align __attribute__((__aligned__(32)));
-      };
-    };
-
 #undef _DEFINE_SPEC_0_HELPER
-#undef _DEFINE_SPEC_1_HELPER
-#undef _DEFINE_SPEC_2_HELPER
 #undef _DEFINE_SPEC
 #undef _DEFINE_SPEC_BODY
-
-_GLIBCXX_END_NAMESPACE
+}
 }
 
-#endif
+#endif // _GLIBCXX_TR1_TYPE_TRAITS
diff --git a/libstdc++-v3/include/tr1/unordered_map b/libstdc++-v3/include/tr1/unordered_map
index 3aca9f5..85e8f00 100644
--- a/libstdc++-v3/include/tr1/unordered_map
+++ b/libstdc++-v3/include/tr1/unordered_map
@@ -31,206 +31,37 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_UNORDERED_MAP
-#define _TR1_UNORDERED_MAP 1
-
-#include <tr1/hashtable>
+#ifndef _GLIBCXX_TR1_UNORDERED_MAP
+#define _GLIBCXX_TR1_UNORDERED_MAP 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
+
+#include <cmath>
+#include <string>
+#include <utility>
+#include <algorithm> // lower_bound
+#include <bits/allocator.h>
+#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
+#include <tr1/type_traits>
 #include <tr1/functional_hash.h>
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-  // XXX When we get typedef templates these class definitions
-  // will be unnecessary.
-  template<class _Key, class _Tp,
-	   class _Hash = hash<_Key>,
-	   class _Pred = std::equal_to<_Key>,
-	   class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
-	   bool __cache_hash_code = false>
-    class __unordered_map
-    : public _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
-			std::_Select1st<std::pair<const _Key, _Tp> >, _Pred, 
-			_Hash, __detail::_Mod_range_hashing,
-			__detail::_Default_ranged_hash,
-			__detail::_Prime_rehash_policy,
-			__cache_hash_code, false, true>
-    {
-      typedef _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
-			 std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
-			 _Hash, __detail::_Mod_range_hashing,
-			 __detail::_Default_ranged_hash,
-			 __detail::_Prime_rehash_policy,
-			 __cache_hash_code, false, true>
-        _Base;
-
-    public:
-      typedef typename _Base::size_type       size_type;
-      typedef typename _Base::hasher          hasher;
-      typedef typename _Base::key_equal       key_equal;
-      typedef typename _Base::allocator_type  allocator_type;
-
-      explicit
-      __unordered_map(size_type __n = 10,
-		      const hasher& __hf = hasher(),
-		      const key_equal& __eql = key_equal(),
-		      const allocator_type& __a = allocator_type())
-      : _Base(__n, __hf, __detail::_Mod_range_hashing(),
-	      __detail::_Default_ranged_hash(),
-	      __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
-      { }
-
-      template<typename _InputIterator>
-        __unordered_map(_InputIterator __f, _InputIterator __l, 
-			size_type __n = 10,
-			const hasher& __hf = hasher(), 
-			const key_equal& __eql = key_equal(), 
-			const allocator_type& __a = allocator_type())
-	: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
-		__detail::_Default_ranged_hash(),
-		__eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
-	{ }
-    };
-  
-  template<class _Key, class _Tp,
-	   class _Hash = hash<_Key>,
-	   class _Pred = std::equal_to<_Key>,
-	   class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
-	   bool __cache_hash_code = false>
-    class __unordered_multimap
-    : public _Hashtable<_Key, std::pair<const _Key, _Tp>,
-			_Alloc,
-			std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
-			_Hash, __detail::_Mod_range_hashing,
-			__detail::_Default_ranged_hash,
-			__detail::_Prime_rehash_policy,
-			__cache_hash_code, false, false>
-    {
-      typedef _Hashtable<_Key, std::pair<const _Key, _Tp>,
-			 _Alloc,
-			 std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
-			 _Hash, __detail::_Mod_range_hashing,
-			 __detail::_Default_ranged_hash,
-			 __detail::_Prime_rehash_policy,
-			 __cache_hash_code, false, false>
-        _Base;
-
-    public:
-      typedef typename _Base::size_type       size_type;
-      typedef typename _Base::hasher          hasher;
-      typedef typename _Base::key_equal       key_equal;
-      typedef typename _Base::allocator_type  allocator_type;
-      
-      explicit
-      __unordered_multimap(size_type __n = 10,
-			   const hasher& __hf = hasher(),
-			   const key_equal& __eql = key_equal(),
-			   const allocator_type& __a = allocator_type())
-      : _Base(__n, __hf, __detail::_Mod_range_hashing(),
-	      __detail::_Default_ranged_hash(),
-	      __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
-      { }
-
-
-      template<typename _InputIterator>
-        __unordered_multimap(_InputIterator __f, _InputIterator __l, 
-			     typename _Base::size_type __n = 0,
-			     const hasher& __hf = hasher(), 
-			     const key_equal& __eql = key_equal(), 
-			     const allocator_type& __a = allocator_type())
-	: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
-		__detail::_Default_ranged_hash(),
-		__eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
-        { }
-    };
-
-  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
-	   bool __cache_hash_code>
-    inline void
-    swap(__unordered_map<_Key, _Tp, _Hash, _Pred,
-	 _Alloc, __cache_hash_code>& __x,
-	 __unordered_map<_Key, _Tp, _Hash, _Pred,
-	 _Alloc, __cache_hash_code>& __y)
-    { __x.swap(__y); }
-
-  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
-	   bool __cache_hash_code>
-    inline void
-    swap(__unordered_multimap<_Key, _Tp, _Hash, _Pred,
-	 _Alloc, __cache_hash_code>& __x,
-	 __unordered_multimap<_Key, _Tp, _Hash, _Pred,
-	 _Alloc, __cache_hash_code>& __y)
-    { __x.swap(__y); }
-
-
-  template<class _Key, class _Tp,
-	   class _Hash = hash<_Key>,
-	   class _Pred = std::equal_to<_Key>,
-	   class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
-    class unordered_map
-    : public __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
-    {
-      typedef __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>  _Base;
-
-    public:
-      typedef typename _Base::size_type       size_type;
-      typedef typename _Base::hasher          hasher;
-      typedef typename _Base::key_equal       key_equal;
-      typedef typename _Base::allocator_type  allocator_type;
-
-      explicit
-      unordered_map(size_type __n = 10,
-		    const hasher& __hf = hasher(),
-		    const key_equal& __eql = key_equal(),
-		    const allocator_type& __a = allocator_type())
-      : _Base(__n, __hf, __eql, __a)
-      { }
-
-      template<typename _InputIterator>
-        unordered_map(_InputIterator __f, _InputIterator __l, 
-		      size_type __n = 10,
-		      const hasher& __hf = hasher(), 
-		      const key_equal& __eql = key_equal(), 
-		      const allocator_type& __a = allocator_type())
-	: _Base(__f, __l, __n, __hf, __eql, __a)
-        { }
-    };
-  
-  template<class _Key, class _Tp,
-	   class _Hash = hash<_Key>,
-	   class _Pred = std::equal_to<_Key>,
-	   class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
-    class unordered_multimap
-    : public __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
-    {
-      typedef __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>  _Base;
-
-    public:
-      typedef typename _Base::size_type       size_type;
-      typedef typename _Base::hasher          hasher;
-      typedef typename _Base::key_equal       key_equal;
-      typedef typename _Base::allocator_type  allocator_type;
-      
-      explicit
-      unordered_multimap(size_type __n = 10,
-			 const hasher& __hf = hasher(),
-			 const key_equal& __eql = key_equal(),
-			 const allocator_type& __a = allocator_type())
-      : _Base(__n, __hf, __eql, __a)
-      { }
-
-
-      template<typename _InputIterator>
-        unordered_multimap(_InputIterator __f, _InputIterator __l, 
-			   typename _Base::size_type __n = 0,
-			   const hasher& __hf = hasher(), 
-			   const key_equal& __eql = key_equal(), 
-			   const allocator_type& __a = allocator_type())
-	: _Base(__f, __l, __n, __hf, __eql, __a)
-        { }
-    };
-
-_GLIBCXX_END_NAMESPACE
-}
-
-#endif // _TR1_UNORDERED_MAP
+#include <tr1/hashtable.h>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/unordered_map>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/unordered_map>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
+#endif
+
+#endif // _GLIBCXX_TR1_UNORDERED_MAP
diff --git a/libstdc++-v3/include/tr1/unordered_set b/libstdc++-v3/include/tr1/unordered_set
index bd56ead..35c605f 100644
--- a/libstdc++-v3/include/tr1/unordered_set
+++ b/libstdc++-v3/include/tr1/unordered_set
@@ -31,204 +31,37 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_UNORDERED_SET
-#define _TR1_UNORDERED_SET 1
-
-#include <tr1/hashtable>
+#ifndef _GLIBCXX_TR1_UNORDERED_SET
+#define _GLIBCXX_TR1_UNORDERED_SET 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
+
+#include <cmath>
+#include <string>
+#include <utility>
+#include <algorithm> // lower_bound
+#include <bits/allocator.h>
+#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
+#include <tr1/type_traits>
 #include <tr1/functional_hash.h>
-
-namespace std
-{ 
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-  // XXX When we get typedef templates these class definitions
-  // will be unnecessary.
-  template<class _Value,
-	   class _Hash = hash<_Value>,
-	   class _Pred = std::equal_to<_Value>,
-	   class _Alloc = std::allocator<_Value>,
-	   bool __cache_hash_code = false>
-    class __unordered_set
-    : public _Hashtable<_Value, _Value, _Alloc,
-			std::_Identity<_Value>, _Pred,
-			_Hash, __detail::_Mod_range_hashing,
-			__detail::_Default_ranged_hash,
-			__detail::_Prime_rehash_policy,
-			__cache_hash_code, true, true>
-    {
-      typedef _Hashtable<_Value, _Value, _Alloc,
-			 std::_Identity<_Value>, _Pred,
-			 _Hash, __detail::_Mod_range_hashing,
-			 __detail::_Default_ranged_hash,
-			 __detail::_Prime_rehash_policy,
-			 __cache_hash_code, true, true>
-        _Base;
-
-    public:
-      typedef typename _Base::size_type       size_type;
-      typedef typename _Base::hasher          hasher;
-      typedef typename _Base::key_equal       key_equal;
-      typedef typename _Base::allocator_type  allocator_type;
-      
-      explicit
-      __unordered_set(size_type __n = 10,
-		      const hasher& __hf = hasher(),
-		      const key_equal& __eql = key_equal(),
-		      const allocator_type& __a = allocator_type())
-      : _Base(__n, __hf, __detail::_Mod_range_hashing(),
-	      __detail::_Default_ranged_hash(), __eql,
-	      std::_Identity<_Value>(), __a)
-      { }
-
-      template<typename _InputIterator>
-        __unordered_set(_InputIterator __f, _InputIterator __l, 
-			size_type __n = 10,
-			const hasher& __hf = hasher(), 
-			const key_equal& __eql = key_equal(), 
-			const allocator_type& __a = allocator_type())
-	: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
-		__detail::_Default_ranged_hash(), __eql,
-		std::_Identity<_Value>(), __a)
-        { }
-    };
-
-  template<class _Value,
-	   class _Hash = hash<_Value>,
-	   class _Pred = std::equal_to<_Value>,
-	   class _Alloc = std::allocator<_Value>,
-	   bool __cache_hash_code = false>
-    class __unordered_multiset
-    : public _Hashtable<_Value, _Value, _Alloc,
-			std::_Identity<_Value>, _Pred,
-			_Hash, __detail::_Mod_range_hashing,
-			__detail::_Default_ranged_hash,
-			__detail::_Prime_rehash_policy,
-			__cache_hash_code, true, false>
-    {
-      typedef _Hashtable<_Value, _Value, _Alloc,
-			 std::_Identity<_Value>, _Pred,
-			 _Hash, __detail::_Mod_range_hashing,
-			 __detail::_Default_ranged_hash,
-			 __detail::_Prime_rehash_policy,
-			 __cache_hash_code, true, false>
-        _Base;
-
-    public:
-      typedef typename _Base::size_type       size_type;
-      typedef typename _Base::hasher          hasher;
-      typedef typename _Base::key_equal       key_equal;
-      typedef typename _Base::allocator_type  allocator_type;
-      
-      explicit
-      __unordered_multiset(size_type __n = 10,
-			   const hasher& __hf = hasher(),
-			   const key_equal& __eql = key_equal(),
-			   const allocator_type& __a = allocator_type())
-      : _Base(__n, __hf, __detail::_Mod_range_hashing(),
-	      __detail::_Default_ranged_hash(), __eql,
-	      std::_Identity<_Value>(), __a)
-      { }
-
-
-      template<typename _InputIterator>
-        __unordered_multiset(_InputIterator __f, _InputIterator __l, 
-			     typename _Base::size_type __n = 0,
-			     const hasher& __hf = hasher(), 
-			     const key_equal& __eql = key_equal(), 
-			     const allocator_type& __a = allocator_type())
-	: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
-		__detail::_Default_ranged_hash(), __eql,
-		std::_Identity<_Value>(), __a)
-        { }
-    };
-
-  template<class _Value, class _Hash, class _Pred, class _Alloc,
-	   bool __cache_hash_code>
-    inline void
-    swap (__unordered_set<_Value, _Hash, _Pred,
-	  _Alloc, __cache_hash_code>& __x,
-	  __unordered_set<_Value, _Hash, _Pred,
-	  _Alloc, __cache_hash_code>& __y)
-    { __x.swap(__y); }
-
-  template<class _Value, class _Hash, class _Pred, class _Alloc,
-	   bool __cache_hash_code>
-    inline void
-    swap(__unordered_multiset<_Value, _Hash, _Pred,
-	 _Alloc, __cache_hash_code>& __x,
-	 __unordered_multiset<_Value, _Hash, _Pred,
-	 _Alloc, __cache_hash_code>& __y)
-    { __x.swap(__y); }
-
-
-  template<class _Value,
-	   class _Hash = hash<_Value>,
-	   class _Pred = std::equal_to<_Value>,
-	   class _Alloc = std::allocator<_Value> >
-    class unordered_set
-    : public __unordered_set<_Value, _Hash, _Pred, _Alloc>
-    {
-      typedef __unordered_set<_Value, _Hash, _Pred, _Alloc>  _Base;
-
-    public:
-      typedef typename _Base::size_type       size_type;
-      typedef typename _Base::hasher          hasher;
-      typedef typename _Base::key_equal       key_equal;
-      typedef typename _Base::allocator_type  allocator_type;
-      
-      explicit
-      unordered_set(size_type __n = 10,
-		    const hasher& __hf = hasher(),
-		    const key_equal& __eql = key_equal(),
-		    const allocator_type& __a = allocator_type())
-      : _Base(__n, __hf, __eql, __a)
-      { }
-
-      template<typename _InputIterator>
-        unordered_set(_InputIterator __f, _InputIterator __l, 
-		      size_type __n = 10,
-		      const hasher& __hf = hasher(), 
-		      const key_equal& __eql = key_equal(), 
-		      const allocator_type& __a = allocator_type())
-	: _Base(__f, __l, __n, __hf, __eql, __a)
-        { }
-    };
-
-  template<class _Value,
-	   class _Hash = hash<_Value>,
-	   class _Pred = std::equal_to<_Value>,
-	   class _Alloc = std::allocator<_Value> >
-    class unordered_multiset
-    : public __unordered_multiset<_Value, _Hash, _Pred, _Alloc>
-    {
-      typedef __unordered_multiset<_Value, _Hash, _Pred, _Alloc>  _Base;
-
-    public:
-      typedef typename _Base::size_type       size_type;
-      typedef typename _Base::hasher          hasher;
-      typedef typename _Base::key_equal       key_equal;
-      typedef typename _Base::allocator_type  allocator_type;
-      
-      explicit
-      unordered_multiset(size_type __n = 10,
-			 const hasher& __hf = hasher(),
-			 const key_equal& __eql = key_equal(),
-			 const allocator_type& __a = allocator_type())
-      : _Base(__n, __hf, __eql, __a)
-      { }
-
-
-      template<typename _InputIterator>
-        unordered_multiset(_InputIterator __f, _InputIterator __l, 
-			   typename _Base::size_type __n = 0,
-			   const hasher& __hf = hasher(), 
-			   const key_equal& __eql = key_equal(), 
-			   const allocator_type& __a = allocator_type())
-	: _Base(__f, __l, __n, __hf, __eql, __a)
-        { }
-    };
-
-_GLIBCXX_END_NAMESPACE
-}
-
-#endif // _TR1_UNORDERED_SET
+#include <tr1/hashtable.h>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/unordered_set>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/unordered_set>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
+#endif
+
+#endif // _GLIBCXX_TR1_UNORDERED_SET
diff --git a/libstdc++-v3/include/tr1/utility b/libstdc++-v3/include/tr1/utility
index efe2503..549411f 100644
--- a/libstdc++-v3/include/tr1/utility
+++ b/libstdc++-v3/include/tr1/utility
@@ -31,72 +31,31 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_UTILITY
-#define _TR1_UTILITY 1
+#ifndef _GLIBCXX_TR1_UTILITY
+#define _GLIBCXX_TR1_UTILITY 1
 
-#include <utility>
+#pragma GCC system_header
 
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-  template<class _Tp> class tuple_size;
-  template<int _Int, class _Tp> class tuple_element;
-
-   // Various functions which give std::pair a tuple-like interface.
-  template<class _Tp1, class _Tp2>
-    struct tuple_size<std::pair<_Tp1, _Tp2> >
-    { static const int value = 2; };
-
-  template<class _Tp1, class _Tp2>
-    const int tuple_size<std::pair<_Tp1, _Tp2> >::value;
-
-  template<class _Tp1, class _Tp2>
-    struct tuple_element<0, std::pair<_Tp1, _Tp2> >
-    { typedef _Tp1 type; };
- 
-  template<class _Tp1, class _Tp2>
-    struct tuple_element<1, std::pair<_Tp1, _Tp2> >
-    { typedef _Tp2 type; };
- 
-
-  template<int _Int> struct __pair_get;
-
-  template<>
-    struct __pair_get<0>
-    {
-      template<typename _Tp1, typename _Tp2>
-      static _Tp1& __get(std::pair<_Tp1, _Tp2>& __pair)
-      { return __pair.first; }
-
-      template<typename _Tp1, typename _Tp2>
-      static const _Tp1& __const_get(const std::pair<_Tp1, _Tp2>& __pair)
-      { return __pair.first; }
-    };
-
-  template<>
-    struct __pair_get<1>
-    {
-      template<typename _Tp1, typename _Tp2>
-      static _Tp2& __get(std::pair<_Tp1, _Tp2>& __pair)
-      { return __pair.second; }
-
-      template<typename _Tp1, typename _Tp2>
-      static const _Tp2& __const_get(const std::pair<_Tp1, _Tp2>& __pair)
-      { return __pair.second; }
-    };
-
-   template<int _Int, class _Tp1, class _Tp2>
-     inline typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
-     get(std::pair<_Tp1, _Tp2>& __in)
-     { return __pair_get<_Int>::__get(__in); }
- 
-   template<int _Int, class _Tp1, class _Tp2>
-     inline const typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
-     get(const std::pair<_Tp1, _Tp2>& __in)
-     { return __pair_get<_Int>::__const_get(__in); }
-
-_GLIBCXX_END_NAMESPACE
-} 
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
 
+#include <bits/c++config.h>
+#include <bits/stl_relops.h>
+#include <bits/stl_pair.h>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/utility>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/utility>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
 #endif
+
+#endif // _GLIBCXX_TR1_UTILITY
diff --git a/libstdc++-v3/include/tr1/wchar.h b/libstdc++-v3/include/tr1/wchar.h
index 00fb8a0..f14a47d 100644
--- a/libstdc++-v3/include/tr1/wchar.h
+++ b/libstdc++-v3/include/tr1/wchar.h
@@ -1,6 +1,6 @@
 // TR1 wchar.h -*- C++ -*-
 
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -31,9 +31,9 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_WCHAR_H
-#define _TR1_WCHAR_H 1
+#ifndef _GLIBCXX_TR1_WCHAR_H
+#define _GLIBCXX_TR1_WCHAR_H 1
 
 #include <tr1/cwchar>
 
-#endif
+#endif // _GLIBCXX_TR1_WCHAR_H
diff --git a/libstdc++-v3/include/tr1/wctype.h b/libstdc++-v3/include/tr1/wctype.h
index 9ef23cd..1337c9b 100644
--- a/libstdc++-v3/include/tr1/wctype.h
+++ b/libstdc++-v3/include/tr1/wctype.h
@@ -1,6 +1,6 @@
 // TR1 wctype.h -*- C++ -*-
 
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -31,9 +31,9 @@
  *  This is a TR1 C++ Library header. 
  */
 
-#ifndef _TR1_WCTYPE_H
-#define _TR1_WCTYPE_H 1
+#ifndef _GLIBCXX_TR1_WCTYPE_H
+#define _GLIBCXX_TR1_WCTYPE_H 1
 
 #include <tr1/cwctype>
 
-#endif
+#endif // _GLIBCXX_TR1_WCTYPE_H
diff --git a/libstdc++-v3/include/tr1_impl/array b/libstdc++-v3/include/tr1_impl/array
new file mode 100644
index 0000000..0fda088
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/array
@@ -0,0 +1,239 @@
+// class template array -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/array
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+  /// @brief  struct array [6.2.2].
+  /// NB: Requires complete type _Tp.
+  template<typename _Tp, std::size_t _Nm>
+    struct array
+    {
+      typedef _Tp 	    			      value_type;
+      typedef value_type&                   	      reference;
+      typedef const value_type&             	      const_reference;
+      typedef value_type*          		      iterator;
+      typedef const value_type*			      const_iterator;
+      typedef std::size_t                    	      size_type;
+      typedef std::ptrdiff_t                   	      difference_type;
+      typedef std::reverse_iterator<iterator>	      reverse_iterator;
+      typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;
+
+      // Support for zero-sized arrays mandatory.
+      value_type _M_instance[_Nm ? _Nm : 1] __attribute__((__aligned__));
+
+      // No explicit construct/copy/destroy for aggregate type.
+
+      void 
+      assign(const value_type& __u)
+      { std::fill_n(begin(), size(), __u); }
+
+      void 
+      swap(array& __other)
+      { std::swap_ranges(begin(), end(), __other.begin()); }
+
+      // Iterators.
+      iterator
+      begin()
+      { return iterator(&_M_instance[0]); }
+
+      const_iterator
+      begin() const 
+      { return const_iterator(&_M_instance[0]); }
+
+      iterator
+      end() 
+      { return iterator(&_M_instance[_Nm]); }
+
+      const_iterator
+      end() const
+      { return const_iterator(&_M_instance[_Nm]); }
+
+      reverse_iterator 
+      rbegin()
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator 
+      rbegin() const
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator 
+      rend()
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator 
+      rend() const
+      { return const_reverse_iterator(begin()); }
+
+      // Capacity.
+      size_type 
+      size() const { return _Nm; }
+
+      size_type 
+      max_size() const { return _Nm; }
+
+      bool 
+      empty() const { return size() == 0; }
+
+      // Element access.
+      reference
+      operator[](size_type __n)
+      { return _M_instance[__n]; }
+
+      const_reference
+      operator[](size_type __n) const
+      { return _M_instance[__n]; }
+
+      reference
+      at(size_type __n)
+      { 
+	_M_check<_Nm>(__n);
+	return _M_instance[__n];
+      }
+
+      const_reference
+      at(size_type __n) const
+      {
+	_M_check<_Nm>(__n);
+	return _M_instance[__n];
+      }
+
+      reference 
+      front()
+      { return *begin(); }
+
+      const_reference 
+      front() const
+      { return *begin(); }
+
+      reference 
+      back()
+      { return _Nm ? *(end() - 1) : *end(); }
+
+      const_reference 
+      back() const
+      { return _Nm ? *(end() - 1) : *end(); }
+
+      _Tp* 
+      data()
+      { return &_M_instance[0]; }
+
+      const _Tp* 
+      data() const
+      { return &_M_instance[0]; }
+
+    private:
+      template<std::size_t _Mm>
+        typename __gnu_cxx::__enable_if<_Mm, void>::__type
+        _M_check(size_type __n) const
+        {
+	  if (__builtin_expect(__n >= _Mm, false))
+	    std::__throw_out_of_range(__N("array::_M_check"));
+	}
+
+      // Avoid "unsigned comparison with zero" warnings.
+      template<std::size_t _Mm>
+        typename __gnu_cxx::__enable_if<!_Mm, void>::__type
+        _M_check(size_type) const
+        { std::__throw_out_of_range(__N("array::_M_check")); }
+    };
+
+  // Array comparisons.
+  template<typename _Tp, std::size_t _Nm>
+    inline bool 
+    operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return std::equal(__one.begin(), __one.end(), __two.begin()); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one == __two); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
+    { 
+      return std::lexicographical_compare(__a.begin(), __a.end(),
+					  __b.begin(), __b.end()); 
+    }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return __two < __one; }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one > __two); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one < __two); }
+
+  // Specialized algorithms [6.2.2.2].
+  template<typename _Tp, std::size_t _Nm>
+    inline void
+    swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
+    { std::swap_ranges(__one.begin(), __one.end(), __two.begin()); }
+
+  // Tuple interface to class template array [6.2.2.5].
+  template<typename _Tp> class tuple_size;
+  template<int _Int, typename _Tp> class tuple_element;
+
+  template<typename _Tp, std::size_t _Nm>
+    struct tuple_size<array<_Tp, _Nm> >
+    { static const int value = _Nm; };
+
+  template<typename _Tp, std::size_t _Nm>
+    const int tuple_size<array<_Tp, _Nm> >::value;
+
+  template<int _Int, typename _Tp, std::size_t _Nm>
+    struct tuple_element<_Int, array<_Tp, _Nm> >
+    { typedef _Tp type; };
+
+  template<int _Int, typename _Tp, std::size_t _Nm>
+    inline _Tp&
+    get(array<_Tp, _Nm>& __arr)
+    { return __arr[_Int]; }
+
+  template<int _Int, typename _Tp, std::size_t _Nm>
+    inline const _Tp&
+    get(const array<_Tp, _Nm>& __arr)
+    { return __arr[_Int]; }
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
diff --git a/libstdc++-v3/include/tr1/boost_shared_ptr.h b/libstdc++-v3/include/tr1_impl/boost_shared_ptr.h
index 0e56af5..1a1af5c 100644
--- a/libstdc++-v3/include/tr1/boost_shared_ptr.h
+++ b/libstdc++-v3/include/tr1_impl/boost_shared_ptr.h
@@ -1,6 +1,6 @@
-// <tr1/boost_shared_ptr.h> -*- C++ -*-
+// <tr1_impl/boost_shared_ptr.h> -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -46,17 +46,14 @@
 
 // GCC Note:  based on version 1.32.0 of the Boost library.
 
-/** @file tr1/boost_shared_ptr.h
+/** @file tr1_impl/boost_shared_ptr.h
  *  This is an internal header file, included by other library headers.
  *  You should not attempt to use it directly.
  */
 
-#ifndef _BOOST_SHARED_PTR_H
-#define _BOOST_SHARED_PTR_H 1
-
 namespace std
 {
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+_GLIBCXX_BEGIN_NAMESPACE_TR1
 
   class bad_weak_ptr : public std::exception
   {
@@ -1141,7 +1138,5 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
       mutable weak_ptr<_Tp>  _M_weak_this;
     };
 
-_GLIBCXX_END_NAMESPACE
-} // namespace std
-
-#endif
+_GLIBCXX_END_NAMESPACE_TR1
+}
diff --git a/libstdc++-v3/include/tr1_impl/cctype b/libstdc++-v3/include/tr1_impl/cctype
new file mode 100644
index 0000000..a227ec9
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/cctype
@@ -0,0 +1,48 @@
+// TR1 cctype -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/cctype
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+#if _GLIBCXX_USE_C99_CTYPE_TR1
+
+#undef isblank
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+  using ::isblank;
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
+
+#endif
diff --git a/libstdc++-v3/include/tr1_impl/cfenv b/libstdc++-v3/include/tr1_impl/cfenv
new file mode 100644
index 0000000..01535e0
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/cfenv
@@ -0,0 +1,77 @@
+// TR1 cfenv -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/cfenv
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+#if _GLIBCXX_USE_C99_FENV_TR1
+
+#include_next <fenv.h>
+
+#undef feclearexcept
+#undef fegetexceptflag
+#undef feraiseexcept
+#undef fesetexceptflag
+#undef fetestexcept
+#undef fegetround
+#undef fesetround
+#undef fegetenv
+#undef feholdexcept
+#undef fesetenv
+#undef feupdateenv
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+  // types
+  using ::fenv_t;
+  using ::fexcept_t;
+
+  // functions
+  using ::feclearexcept;
+  using ::fegetexceptflag;
+  using ::feraiseexcept;
+  using ::fesetexceptflag;
+  using ::fetestexcept;
+
+  using ::fegetround;
+  using ::fesetround;
+
+  using ::fegetenv;
+  using ::feholdexcept;
+  using ::fesetenv;
+  using ::feupdateenv;
+  
+_GLIBCXX_END_NAMESPACE_TR1
+}
+
+#endif
diff --git a/libstdc++-v3/include/tr1_impl/cinttypes b/libstdc++-v3/include/tr1_impl/cinttypes
new file mode 100644
index 0000000..05b5251
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/cinttypes
@@ -0,0 +1,73 @@
+// TR1 cinttypes -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/cinttypes
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+#if _GLIBCXX_USE_C99_INTTYPES_TR1
+
+// For 8.11.1/1 (see C99, Note 184) 
+#define __STDC_FORMAT_MACROS
+#include_next <inttypes.h>
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+  // types
+  using ::imaxdiv_t;
+
+  // functions
+  using ::imaxabs;
+
+  // May collide with _Longlong abs(_Longlong), and is not described
+  // anywhere outside the synopsis.  Likely, a defect.
+  //
+  // intmax_t abs(intmax_t)
+
+  using ::imaxdiv;
+
+  // Likewise, with lldiv_t div(_Longlong, _Longlong).
+  //
+  // imaxdiv_t div(intmax_t, intmax_t)
+
+  using ::strtoimax;
+  using ::strtoumax;
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  using ::wcstoimax;
+  using ::wcstoumax;
+#endif
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
+
+#endif
diff --git a/libstdc++-v3/include/tr1_impl/cmath b/libstdc++-v3/include/tr1_impl/cmath
new file mode 100644
index 0000000..3bbbda2
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/cmath
@@ -0,0 +1,907 @@
+// TR1 cmath -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/cmath
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+#if _GLIBCXX_USE_C99_MATH_TR1
+
+#undef acosh
+#undef acoshf
+#undef acoshl
+#undef asinh
+#undef asinhf
+#undef asinhl
+#undef atanh
+#undef atanhf
+#undef atanhl
+#undef cbrt
+#undef cbrtf
+#undef cbrtl
+#undef copysign
+#undef copysignf
+#undef copysignl
+#undef erf
+#undef erff
+#undef erfl
+#undef erfc
+#undef erfcf
+#undef erfcl
+#undef exp2
+#undef exp2f
+#undef exp2l
+#undef expm1
+#undef expm1f
+#undef expm1l
+#undef fdim
+#undef fdimf
+#undef fdiml
+#undef fma
+#undef fmaf
+#undef fmal
+#undef fmax
+#undef fmaxf
+#undef fmaxl
+#undef fmin
+#undef fminf
+#undef fminl
+#undef hypot
+#undef hypotf
+#undef hypotl
+#undef ilogb
+#undef ilogbf
+#undef ilogbl
+#undef lgamma
+#undef lgammaf
+#undef lgammal
+#undef llrint
+#undef llrintf
+#undef llrintl
+#undef llround
+#undef llroundf
+#undef llroundl
+#undef log1p
+#undef log1pf
+#undef log1pl
+#undef log2
+#undef log2f
+#undef log2l
+#undef logb
+#undef logbf
+#undef logbl
+#undef lrint
+#undef lrintf
+#undef lrintl
+#undef lround
+#undef lroundf
+#undef lroundl
+#undef nan
+#undef nanf
+#undef nanl
+#undef nearbyint
+#undef nearbyintf
+#undef nearbyintl
+#undef nextafter
+#undef nextafterf
+#undef nextafterl
+#undef nexttoward
+#undef nexttowardf
+#undef nexttowardl
+#undef remainder
+#undef remainderf
+#undef remainderl
+#undef remquo
+#undef remquo
+#undef remquo
+#undef rint
+#undef rintf
+#undef rintl
+#undef round
+#undef roundf
+#undef roundl
+#undef scalbln
+#undef scalblnf
+#undef scalblnl
+#undef scalbn
+#undef scalbnf
+#undef scalbnl
+#undef tgamma
+#undef tgammaf
+#undef tgammal
+#undef trunc
+#undef truncf
+#undef truncl
+
+#endif
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+#if _GLIBCXX_USE_C99_MATH_TR1
+
+  // types
+  using ::double_t;
+  using ::float_t;
+
+  // functions
+  using ::acosh;
+  using ::acoshf;
+  using ::acoshl;
+
+  using ::asinh;
+  using ::asinhf;
+  using ::asinhl;
+
+  using ::atanh;
+  using ::atanhf;
+  using ::atanhl;
+
+  using ::cbrt;
+  using ::cbrtf;
+  using ::cbrtl;
+
+  using ::copysign;
+  using ::copysignf;
+  using ::copysignl;
+
+  using ::erf;
+  using ::erff;
+  using ::erfl;
+
+  using ::erfc;
+  using ::erfcf;
+  using ::erfcl;
+
+  using ::exp2;
+  using ::exp2f;
+  using ::exp2l;
+
+  using ::expm1;
+  using ::expm1f;
+  using ::expm1l;
+
+  using ::fdim;
+  using ::fdimf;
+  using ::fdiml;
+
+  using ::fma;
+  using ::fmaf;
+  using ::fmal;
+
+  using ::fmax;
+  using ::fmaxf;
+  using ::fmaxl;
+
+  using ::fmin;
+  using ::fminf;
+  using ::fminl;
+
+  using ::hypot;
+  using ::hypotf;
+  using ::hypotl;
+
+  using ::ilogb;
+  using ::ilogbf;
+  using ::ilogbl;
+
+  using ::lgamma;
+  using ::lgammaf;
+  using ::lgammal;
+
+  using ::llrint;
+  using ::llrintf;
+  using ::llrintl;
+
+  using ::llround;
+  using ::llroundf;
+  using ::llroundl;
+
+  using ::log1p;
+  using ::log1pf;
+  using ::log1pl;
+
+  using ::log2;
+  using ::log2f;
+  using ::log2l;
+
+  using ::logb;
+  using ::logbf;
+  using ::logbl;
+
+  using ::lrint;
+  using ::lrintf;
+  using ::lrintl;
+
+  using ::lround;
+  using ::lroundf;
+  using ::lroundl;
+
+  using ::nan;
+  using ::nanf;
+  using ::nanl;
+
+  using ::nearbyint;
+  using ::nearbyintf;
+  using ::nearbyintl;
+
+  using ::nextafter;
+  using ::nextafterf;
+  using ::nextafterl;
+
+  using ::nexttoward;
+  using ::nexttowardf;
+  using ::nexttowardl;
+
+  using ::remainder;
+  using ::remainderf;
+  using ::remainderl;
+
+  using ::remquo;
+  using ::remquo;
+  using ::remquo;
+
+  using ::rint;
+  using ::rintf;
+  using ::rintl;
+
+  using ::round;
+  using ::roundf;
+  using ::roundl;
+
+  using ::scalbln;
+  using ::scalblnf;
+  using ::scalblnl;
+
+  using ::scalbn;
+  using ::scalbnf;
+  using ::scalbnl;
+
+  using ::tgamma;
+  using ::tgammaf;
+  using ::tgammal;
+
+  using ::trunc;
+  using ::truncf;
+  using ::truncl;
+
+#endif
+
+#if _GLIBCXX_USE_C99_MATH
+#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
+
+  /// @brief Function template definitions [8.16.3].
+  //
+  using std::signbit;
+  
+  using std::fpclassify;
+
+  using std::isfinite;
+  using std::isinf;
+  using std::isnan;
+  using std::isnormal;
+
+  using std::isgreater;
+  using std::isgreaterequal;
+  using std::isless;
+  using std::islessequal;
+  using std::islessgreater;
+  using std::isunordered;
+#endif
+#endif
+
+#if _GLIBCXX_USE_C99_MATH_TR1
+
+  /// @brief Additional overloads [8.16.4].
+  //
+  using std::acos;
+
+  inline float
+  acosh(float __x)
+  { return __builtin_acoshf(__x); }
+
+  inline long double
+  acosh(long double __x)
+  { return __builtin_acoshl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type 
+    acosh(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return acosh(__type(__x));
+    }
+
+  using std::asin;
+
+  inline float
+  asinh(float __x)
+  { return __builtin_asinhf(__x); }
+
+  inline long double
+  asinh(long double __x)
+  { return __builtin_asinhl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type 
+    asinh(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return asinh(__type(__x));
+    }
+
+  using std::atan;
+  using std::atan2;
+
+  inline float
+  atanh(float __x)
+  { return __builtin_atanhf(__x); }
+
+  inline long double
+  atanh(long double __x)
+  { return __builtin_atanhl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type 
+    atanh(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return atanh(__type(__x));
+    }
+
+  inline float
+  cbrt(float __x)
+  { return __builtin_cbrtf(__x); }
+
+  inline long double
+  cbrt(long double __x)
+  { return __builtin_cbrtl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type 
+    cbrt(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return cbrt(__type(__x));
+    }
+
+  using std::ceil;
+
+  inline float
+  copysign(float __x, float __y)
+  { return __builtin_copysignf(__x, __y); }
+
+  inline long double
+  copysign(long double __x, long double __y)
+  { return __builtin_copysignl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    copysign(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return copysign(__type(__x), __type(__y));
+    }
+
+  using std::cos;
+  using std::cosh;  
+
+  inline float
+  erf(float __x)
+  { return __builtin_erff(__x); }
+
+  inline long double
+  erf(long double __x)
+  { return __builtin_erfl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type 
+    erf(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return erf(__type(__x));
+    }
+
+  inline float
+  erfc(float __x)
+  { return __builtin_erfcf(__x); }
+
+  inline long double
+  erfc(long double __x)
+  { return __builtin_erfcl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type 
+    erfc(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return erfc(__type(__x));
+    }
+
+  using std::exp;
+
+  inline float
+  exp2(float __x)
+  { return __builtin_exp2f(__x); }
+
+  inline long double
+  exp2(long double __x)
+  { return __builtin_exp2l(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type 
+    exp2(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return exp2(__type(__x));
+    }
+
+  inline float
+  expm1(float __x)
+  { return __builtin_expm1f(__x); }
+
+  inline long double
+  expm1(long double __x)
+  { return __builtin_expm1l(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type 
+    expm1(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return expm1(__type(__x));
+    }
+
+  using std::fabs;
+
+  inline float
+  fdim(float __x, float __y)
+  { return __builtin_fdimf(__x, __y); }
+
+  inline long double
+  fdim(long double __x, long double __y)
+  { return __builtin_fdiml(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fdim(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fdim(__type(__x), __type(__y));
+    }
+
+  using std::floor;
+
+  inline float
+  fma(float __x, float __y, float __z)
+  { return __builtin_fmaf(__x, __y, __z); }
+
+  inline long double
+  fma(long double __x, long double __y, long double __z)
+  { return __builtin_fmal(__x, __y, __z); }
+
+  template<typename _Tp, typename _Up, typename _Vp>
+    inline typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
+    fma(_Tp __x, _Up __y, _Vp __z)
+    {
+      typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
+      return fma(__type(__x), __type(__y), __type(__z));
+    }
+
+  inline float
+  fmax(float __x, float __y)
+  { return __builtin_fmaxf(__x, __y); }
+
+  inline long double
+  fmax(long double __x, long double __y)
+  { return __builtin_fmaxl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fmax(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fmax(__type(__x), __type(__y));
+    }
+
+  inline float
+  fmin(float __x, float __y)
+  { return __builtin_fminf(__x, __y); }
+
+  inline long double
+  fmin(long double __x, long double __y)
+  { return __builtin_fminl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fmin(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fmin(__type(__x), __type(__y));
+    }
+
+  using std::fmod;
+  using std::frexp;
+
+  inline float
+  hypot(float __x, float __y)
+  { return __builtin_hypotf(__x, __y); }
+
+  inline long double
+  hypot(long double __x, long double __y)
+  { return __builtin_hypotl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    hypot(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return hypot(__type(__x), __type(__y));
+    }
+
+  inline int
+  ilogb(float __x)
+  { return __builtin_ilogbf(__x); }
+
+  inline int
+  ilogb(long double __x)
+  { return __builtin_ilogbl(__x); }
+
+  template<typename _Tp>
+    inline int
+    ilogb(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return ilogb(__type(__x));
+    }
+
+  using std::ldexp;
+
+  inline float
+  lgamma(float __x)
+  { return __builtin_lgammaf(__x); }
+
+  inline long double
+  lgamma(long double __x)
+  { return __builtin_lgammal(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type 
+    lgamma(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return lgamma(__type(__x));
+    }
+
+  inline long long
+  llrint(float __x)
+  { return __builtin_llrintf(__x); }
+
+  inline long long
+  llrint(long double __x)
+  { return __builtin_llrintl(__x); }
+
+  template<typename _Tp>
+    inline long long
+    llrint(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return llrint(__type(__x));
+    }
+
+  inline long long
+  llround(float __x)
+  { return __builtin_llroundf(__x); }
+
+  inline long long
+  llround(long double __x)
+  { return __builtin_llroundl(__x); }
+
+  template<typename _Tp>
+    inline long long
+    llround(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return llround(__type(__x));
+    }
+
+  using std::log;
+  using std::log10;
+
+  inline float
+  log1p(float __x)
+  { return __builtin_log1pf(__x); }
+
+  inline long double
+  log1p(long double __x)
+  { return __builtin_log1pl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type 
+    log1p(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return log1p(__type(__x));
+    }
+
+  // DR 568.
+  inline float
+  log2(float __x)
+  { return __builtin_log2f(__x); }
+
+  inline long double
+  log2(long double __x)
+  { return __builtin_log2l(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type 
+    log2(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return log2(__type(__x));
+    }
+
+  inline float
+  logb(float __x)
+  { return __builtin_logbf(__x); }
+
+  inline long double
+  logb(long double __x)
+  { return __builtin_logbl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type 
+    logb(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return logb(__type(__x));
+    }
+
+  inline long
+  lrint(float __x)
+  { return __builtin_lrintf(__x); }
+
+  inline long
+  lrint(long double __x)
+  { return __builtin_lrintl(__x); }
+
+  template<typename _Tp>
+    inline long
+    lrint(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return lrint(__type(__x));
+    }
+
+  inline long
+  lround(float __x)
+  { return __builtin_lroundf(__x); }
+
+  inline long
+  lround(long double __x)
+  { return __builtin_lroundl(__x); }
+
+  template<typename _Tp>
+    inline long
+    lround(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return lround(__type(__x));
+    }
+
+  inline float
+  nearbyint(float __x)
+  { return __builtin_nearbyintf(__x); }
+
+  inline long double
+  nearbyint(long double __x)
+  { return __builtin_nearbyintl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type 
+    nearbyint(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return nearbyint(__type(__x));
+    }
+
+  inline float
+  nextafter(float __x, float __y)
+  { return __builtin_nextafterf(__x, __y); }
+
+  inline long double
+  nextafter(long double __x, long double __y)
+  { return __builtin_nextafterl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    nextafter(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return nextafter(__type(__x), __type(__y));
+    }
+
+  inline float
+  nexttoward(float __x, long double __y)
+  { return __builtin_nexttowardf(__x, __y); }
+
+  inline long double
+  nexttoward(long double __x, long double __y)
+  { return __builtin_nexttowardl(__x, __y); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    nexttoward(_Tp __x, long double __y)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return nexttoward(__type(__x), __y);
+    }
+
+  using std::pow;
+
+  inline float
+  remainder(float __x, float __y)
+  { return __builtin_remainderf(__x, __y); }
+
+  inline long double
+  remainder(long double __x, long double __y)
+  { return __builtin_remainderl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    remainder(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return remainder(__type(__x), __type(__y));
+    }
+
+  inline float
+  remquo(float __x, float __y, int* __pquo)
+  { return __builtin_remquof(__x, __y, __pquo); }
+
+  inline long double
+  remquo(long double __x, long double __y, int* __pquo)
+  { return __builtin_remquol(__x, __y, __pquo); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    remquo(_Tp __x, _Up __y, int* __pquo)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return remquo(__type(__x), __type(__y), __pquo);
+    }
+
+  inline float
+  rint(float __x)
+  { return __builtin_rintf(__x); }
+
+  inline long double
+  rint(long double __x)
+  { return __builtin_rintl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    rint(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return rint(__type(__x));
+    }
+
+  inline float
+  round(float __x)
+  { return __builtin_roundf(__x); }
+
+  inline long double
+  round(long double __x)
+  { return __builtin_roundl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    round(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return round(__type(__x));
+    }
+
+  inline float
+  scalbln(float __x, long __ex)
+  { return __builtin_scalblnf(__x, __ex); }
+
+  inline long double
+  scalbln(long double __x, long __ex)
+  { return __builtin_scalblnl(__x, __ex); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type 
+    scalbln(_Tp __x, long __ex)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return scalbln(__type(__x), __ex);
+    }
+ 
+  inline float
+  scalbn(float __x, int __ex)
+  { return __builtin_scalbnf(__x, __ex); }
+
+  inline long double
+  scalbn(long double __x, int __ex)
+  { return __builtin_scalbnl(__x, __ex); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type 
+    scalbn(_Tp __x, int __ex)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return scalbn(__type(__x), __ex);
+    }
+
+  using std::sin;
+  using std::sinh;
+  using std::sqrt;
+  using std::tan;
+  using std::tanh;
+
+  inline float
+  tgamma(float __x)
+  { return __builtin_tgammaf(__x); }
+
+  inline long double
+  tgamma(long double __x)
+  { return __builtin_tgammal(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type 
+    tgamma(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return tgamma(__type(__x));
+    }
+ 
+  inline float
+  trunc(float __x)
+  { return __builtin_truncf(__x); }
+
+  inline long double
+  trunc(long double __x)
+  { return __builtin_truncl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type 
+    trunc(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return trunc(__type(__x));
+    }
+
+#endif
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
diff --git a/libstdc++-v3/include/tr1_impl/complex b/libstdc++-v3/include/tr1_impl/complex
new file mode 100644
index 0000000..f763182
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/complex
@@ -0,0 +1,369 @@
+// TR1 complex -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/complex
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+  // Forward declarations.
+  template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
+  template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
+  template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
+
+  template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
+  template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
+  template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
+  template<typename _Tp> std::complex<_Tp> fabs(const std::complex<_Tp>&);
+
+  /// @brief acos(__z) [8.1.2].
+  //  Effects:  Behaves the same as C99 function cacos, defined
+  //            in subclause 7.3.5.1.
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    __complex_acos(const std::complex<_Tp>& __z)
+    {
+      const std::complex<_Tp> __t = std::_GLIBCXX_TR1 asin(__z);
+      const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
+      return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+  inline __complex__ float
+  __complex_acos(__complex__ float __z)
+  { return __builtin_cacosf(__z); }
+
+  inline __complex__ double
+  __complex_acos(__complex__ double __z)
+  { return __builtin_cacos(__z); }
+
+  inline __complex__ long double
+  __complex_acos(const __complex__ long double& __z)
+  { return __builtin_cacosl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    acos(const std::complex<_Tp>& __z)
+    { return __complex_acos(__z.__rep()); }
+#else
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    acos(const std::complex<_Tp>& __z)
+    { return __complex_acos(__z); }
+#endif
+
+  /// @brief asin(__z) [8.1.3].
+  //  Effects:  Behaves the same as C99 function casin, defined
+  //            in subclause 7.3.5.2.
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    __complex_asin(const std::complex<_Tp>& __z)
+    {
+      std::complex<_Tp> __t(-__z.imag(), __z.real());
+      __t = std::_GLIBCXX_TR1 asinh(__t);
+      return std::complex<_Tp>(__t.imag(), -__t.real());
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+  inline __complex__ float
+  __complex_asin(__complex__ float __z)
+  { return __builtin_casinf(__z); }
+
+  inline __complex__ double
+  __complex_asin(__complex__ double __z)
+  { return __builtin_casin(__z); }
+
+  inline __complex__ long double
+  __complex_asin(const __complex__ long double& __z)
+  { return __builtin_casinl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    asin(const std::complex<_Tp>& __z)
+    { return __complex_asin(__z.__rep()); }
+#else
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    asin(const std::complex<_Tp>& __z)
+    { return __complex_asin(__z); }
+#endif
+  
+  /// @brief atan(__z) [8.1.4].
+  //  Effects:  Behaves the same as C99 function catan, defined
+  //            in subclause 7.3.5.3.
+  template<typename _Tp>
+    std::complex<_Tp>
+    __complex_atan(const std::complex<_Tp>& __z)
+    {
+      const _Tp __r2 = __z.real() * __z.real();
+      const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
+
+      _Tp __num = __z.imag() + _Tp(1.0);
+      _Tp __den = __z.imag() - _Tp(1.0);
+
+      __num = __r2 + __num * __num;
+      __den = __r2 + __den * __den;
+
+      return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
+			       _Tp(0.25) * log(__num / __den));
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+  inline __complex__ float
+  __complex_atan(__complex__ float __z)
+  { return __builtin_catanf(__z); }
+
+  inline __complex__ double
+  __complex_atan(__complex__ double __z)
+  { return __builtin_catan(__z); }
+
+  inline __complex__ long double
+  __complex_atan(const __complex__ long double& __z)
+  { return __builtin_catanl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    atan(const std::complex<_Tp>& __z)
+    { return __complex_atan(__z.__rep()); }
+#else
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    atan(const std::complex<_Tp>& __z)
+    { return __complex_atan(__z); }
+#endif
+
+  /// @brief acosh(__z) [8.1.5].
+  //  Effects:  Behaves the same as C99 function cacosh, defined
+  //            in subclause 7.3.6.1.
+  template<typename _Tp>
+    std::complex<_Tp>
+    __complex_acosh(const std::complex<_Tp>& __z)
+    {
+      std::complex<_Tp> __t((__z.real() - __z.imag())
+			    * (__z.real() + __z.imag()) - _Tp(1.0),
+			    _Tp(2.0) * __z.real() * __z.imag());
+      __t = std::sqrt(__t);
+
+      return std::log(__t + __z);
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+  inline __complex__ float
+  __complex_acosh(__complex__ float __z)
+  { return __builtin_cacoshf(__z); }
+
+  inline __complex__ double
+  __complex_acosh(__complex__ double __z)
+  { return __builtin_cacosh(__z); }
+
+  inline __complex__ long double
+  __complex_acosh(const __complex__ long double& __z)
+  { return __builtin_cacoshl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    acosh(const std::complex<_Tp>& __z)
+    { return __complex_acosh(__z.__rep()); }
+#else
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    acosh(const std::complex<_Tp>& __z)
+    { return __complex_acosh(__z); }
+#endif
+
+  /// @brief asinh(__z) [8.1.6].
+  //  Effects:  Behaves the same as C99 function casin, defined
+  //            in subclause 7.3.6.2.
+  template<typename _Tp>
+    std::complex<_Tp>
+    __complex_asinh(const std::complex<_Tp>& __z)
+    {
+      std::complex<_Tp> __t((__z.real() - __z.imag())
+			    * (__z.real() + __z.imag()) + _Tp(1.0),
+			    _Tp(2.0) * __z.real() * __z.imag());
+      __t = std::sqrt(__t);
+
+      return std::log(__t + __z);
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+  inline __complex__ float
+  __complex_asinh(__complex__ float __z)
+  { return __builtin_casinhf(__z); }
+
+  inline __complex__ double
+  __complex_asinh(__complex__ double __z)
+  { return __builtin_casinh(__z); }
+
+  inline __complex__ long double
+  __complex_asinh(const __complex__ long double& __z)
+  { return __builtin_casinhl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    asinh(const std::complex<_Tp>& __z)
+    { return __complex_asinh(__z.__rep()); }
+#else
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    asinh(const std::complex<_Tp>& __z)
+    { return __complex_asinh(__z); }
+#endif
+
+  /// @brief atanh(__z) [8.1.7].
+  //  Effects:  Behaves the same as C99 function catanh, defined
+  //            in subclause 7.3.6.3.
+  template<typename _Tp>
+    std::complex<_Tp>
+    __complex_atanh(const std::complex<_Tp>& __z)
+    {
+      const _Tp __i2 = __z.imag() * __z.imag();
+      const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
+
+      _Tp __num = _Tp(1.0) + __z.real();
+      _Tp __den = _Tp(1.0) - __z.real();
+
+      __num = __i2 + __num * __num;
+      __den = __i2 + __den * __den;
+
+      return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
+			       _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+  inline __complex__ float
+  __complex_atanh(__complex__ float __z)
+  { return __builtin_catanhf(__z); }
+
+  inline __complex__ double
+  __complex_atanh(__complex__ double __z)
+  { return __builtin_catanh(__z); }
+
+  inline __complex__ long double
+  __complex_atanh(const __complex__ long double& __z)
+  { return __builtin_catanhl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    atanh(const std::complex<_Tp>& __z)
+    { return __complex_atanh(__z.__rep()); }
+#else
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    atanh(const std::complex<_Tp>& __z)
+    { return __complex_atanh(__z); }
+#endif
+
+  /// @brief fabs(__z) [8.1.8].
+  //  Effects:  Behaves the same as C99 function cabs, defined
+  //            in subclause 7.3.8.1.
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    fabs(const std::complex<_Tp>& __z)
+    { return std::abs(__z); }
+
+
+#if (defined(_GLIBCXX_INCLUDE_AS_CXX0X) \
+     || (defined(_GLIBCXX_INCLUDE_AS_TR1) \
+	 && !defined(__GXX_EXPERIMENTAL_CXX0X__)))
+
+  /// @brief Additional overloads [8.1.9].
+  //
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    arg(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return std::arg(std::complex<__type>(__x));
+    }
+
+  template<typename _Tp>
+    inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
+    conj(_Tp __x)
+    { return __x; }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    imag(_Tp)
+    { return _Tp(); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    norm(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __type(__x) * __type(__x);
+    }
+
+  template<typename _Tp, typename _Up>
+    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+    polar(const _Tp& __rho, const _Up& __theta)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return std::polar(__type(__rho), __type(__theta));
+    }
+  
+  template<typename _Tp, typename _Up>
+    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+    pow(const std::complex<_Tp>& __x, const _Up& __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return std::pow(std::complex<__type>(__x), __type(__y));
+    }
+
+  template<typename _Tp, typename _Up>
+    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+    pow(const _Tp& __x, const std::complex<_Up>& __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return std::pow(__type(__x), std::complex<__type>(__y));
+    }
+
+  template<typename _Tp, typename _Up>
+    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+    pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return std::pow(std::complex<__type>(__x),
+		      std::complex<__type>(__y));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    real(_Tp __x)
+    { return __x; }
+
+#endif
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
diff --git a/libstdc++-v3/include/tr1_impl/cstdint b/libstdc++-v3/include/tr1_impl/cstdint
new file mode 100644
index 0000000..862ee97
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/cstdint
@@ -0,0 +1,85 @@
+// TR1 cstdint -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/cstdint
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+#if _GLIBCXX_USE_C99_STDINT_TR1
+
+// For 8.22.1/1 (see C99, Notes 219, 220, 222) 
+#define __STDC_LIMIT_MACROS
+#define __STDC_CONSTANT_MACROS
+#include_next <stdint.h>
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+  using ::int8_t;
+  using ::int16_t;
+  using ::int32_t;
+  using ::int64_t;
+
+  using ::int_fast8_t;
+  using ::int_fast16_t;
+  using ::int_fast32_t;
+  using ::int_fast64_t;
+
+  using ::int_least8_t;
+  using ::int_least16_t;
+  using ::int_least32_t;
+  using ::int_least64_t;
+
+  using ::intmax_t;
+  using ::intptr_t;
+  
+  using ::uint8_t;
+  using ::uint16_t;
+  using ::uint32_t;
+  using ::uint64_t;
+
+  using ::uint_fast8_t;
+  using ::uint_fast16_t;
+  using ::uint_fast32_t;
+  using ::uint_fast64_t;
+
+  using ::uint_least8_t;
+  using ::uint_least16_t;
+  using ::uint_least32_t;
+  using ::uint_least64_t;
+
+  using ::uintmax_t;
+  using ::uintptr_t;
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
+
+#endif
diff --git a/libstdc++-v3/include/tr1_impl/cstdio b/libstdc++-v3/include/tr1_impl/cstdio
new file mode 100644
index 0000000..f45adea
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/cstdio
@@ -0,0 +1,49 @@
+// TR1 cstdio -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/cstdio
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+#if _GLIBCXX_USE_C99
+  using std::snprintf;
+  using std::vsnprintf;
+
+  using std::vfscanf;
+  using std::vscanf;
+  using std::vsscanf;
+#endif
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
diff --git a/libstdc++-v3/include/tr1_impl/cstdlib b/libstdc++-v3/include/tr1_impl/cstdlib
new file mode 100644
index 0000000..482f20c
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/cstdlib
@@ -0,0 +1,70 @@
+// TR1 cstdlib -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/cstdlib
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+#if _GLIBCXX_HOSTED
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+#if _GLIBCXX_USE_C99
+
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  // types
+  using std::lldiv_t;
+
+  // functions
+  using std::llabs;
+  using std::lldiv;
+#endif
+
+  using std::atoll;
+  using std::strtoll;
+  using std::strtoull;
+
+  using std::strtof;
+  using std::strtold;
+
+  // overloads
+  using std::abs;
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  using std::div;
+#endif
+
+#endif
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
+
+#endif
diff --git a/libstdc++-v3/include/tr1_impl/cwchar b/libstdc++-v3/include/tr1_impl/cwchar
new file mode 100644
index 0000000..a0f8e2d
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/cwchar
@@ -0,0 +1,63 @@
+// TR1 cwchar -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/cwchar
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+#if _GLIBCXX_USE_WCHAR_T
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+#if _GLIBCXX_HAVE_WCSTOF
+  using std::wcstof;
+#endif
+#if _GLIBCXX_HAVE_VFWSCANF
+  using std::vfwscanf;
+#endif
+#if _GLIBCXX_HAVE_VSWSCANF
+  using std::vswscanf;
+#endif
+#if _GLIBCXX_HAVE_VWSCANF
+  using std::vwscanf;
+#endif
+
+#if _GLIBCXX_USE_C99
+  using std::wcstold;
+  using std::wcstoll;
+  using std::wcstoull;
+#endif
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
+
+#endif
diff --git a/libstdc++-v3/include/tr1_impl/cwctype b/libstdc++-v3/include/tr1_impl/cwctype
new file mode 100644
index 0000000..51a2e91
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/cwctype
@@ -0,0 +1,48 @@
+// TR1 cwctype -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/cwctype
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+#if _GLIBCXX_USE_WCHAR_T
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+#if _GLIBCXX_HAVE_ISWBLANK
+  using std::iswblank;
+#endif  
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
+
+#endif
diff --git a/libstdc++-v3/include/tr1_impl/functional b/libstdc++-v3/include/tr1_impl/functional
new file mode 100644
index 0000000..0005dfc
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/functional
@@ -0,0 +1,2294 @@
+// TR1 functional header -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/functional
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+  template<typename _MemberPointer>
+    class _Mem_fn;
+
+  /**
+   *  @if maint
+   *  Actual implementation of _Has_result_type, which uses SFINAE to
+   *  determine if the type _Tp has a publicly-accessible member type
+   *  result_type.
+   *  @endif
+  */
+  template<typename _Tp>
+    class _Has_result_type_helper : __sfinae_types
+    {
+      template<typename _Up>
+        struct _Wrap_type
+	{ };
+
+      template<typename _Up>
+        static __one __test(_Wrap_type<typename _Up::result_type>*);
+
+      template<typename _Up>
+        static __two __test(...);
+
+    public:
+      static const bool value = sizeof(__test<_Tp>(0)) == 1;
+    };
+
+  template<typename _Tp>
+    struct _Has_result_type
+    : integral_constant<bool,
+	      _Has_result_type_helper<typename remove_cv<_Tp>::type>::value>
+    { };
+
+  /**
+   *  @if maint
+   *  If we have found a result_type, extract it.
+   *  @endif
+  */
+  template<bool _Has_result_type, typename _Functor>
+    struct _Maybe_get_result_type
+    { };
+
+  template<typename _Functor>
+    struct _Maybe_get_result_type<true, _Functor>
+    {
+      typedef typename _Functor::result_type result_type;
+    };
+
+  /**
+   *  @if maint
+   *  Base class for any function object that has a weak result type, as
+   *  defined in 3.3/3 of TR1.
+   *  @endif
+  */
+  template<typename _Functor>
+    struct _Weak_result_type_impl
+    : _Maybe_get_result_type<_Has_result_type<_Functor>::value, _Functor>
+    {
+    };
+
+  /**
+   * @if maint
+   * Retrieve the result type for a function type.
+   * @endif 
+   */
+  template<typename _Res, typename... _ArgTypes> 
+    struct _Weak_result_type_impl<_Res(_ArgTypes...)>
+    {
+      typedef _Res result_type;
+    };
+
+  /**
+   * @if maint
+   * Retrieve the result type for a function reference.
+   * @endif 
+   */
+  template<typename _Res, typename... _ArgTypes> 
+    struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
+    {
+      typedef _Res result_type;
+    };
+
+  /**
+   * @if maint
+   * Retrieve the result type for a function pointer.
+   * @endif 
+   */
+  template<typename _Res, typename... _ArgTypes> 
+    struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
+    {
+      typedef _Res result_type;
+    };
+
+  /**
+   * @if maint
+   * Retrieve result type for a member function pointer.
+   * @endif maint
+   */ 
+  template<typename _Res, typename _Class, typename... _ArgTypes> 
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
+    {
+      typedef _Res result_type;
+    };
+
+  /**
+   * @if maint
+   * Retrieve result type for a const member function pointer.
+   * @endif maint
+   */ 
+  template<typename _Res, typename _Class, typename... _ArgTypes> 
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
+    {
+      typedef _Res result_type;
+    };
+
+  /**
+   * @if maint
+   * Retrieve result type for a volatile member function pointer.
+   * @endif maint
+   */ 
+  template<typename _Res, typename _Class, typename... _ArgTypes> 
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
+    {
+      typedef _Res result_type;
+    };
+
+  /**
+   * @if maint
+   * Retrieve result type for a const volatile member function pointer.
+   * @endif maint
+   */ 
+  template<typename _Res, typename _Class, typename... _ArgTypes> 
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)const volatile>
+    {
+      typedef _Res result_type;
+    };
+
+  /**
+   *  @if maint
+   *  Strip top-level cv-qualifiers from the function object and let
+   *  _Weak_result_type_impl perform the real work.
+   *  @endif
+  */
+  template<typename _Functor>
+    struct _Weak_result_type
+    : _Weak_result_type_impl<typename remove_cv<_Functor>::type>
+    {
+    };
+
+  template<typename _Signature>
+    class result_of;
+
+  /**
+   *  @if maint
+   *  Actual implementation of result_of. When _Has_result_type is
+   *  true, gets its result from _Weak_result_type. Otherwise, uses
+   *  the function object's member template result to extract the
+   *  result type.
+   *  @endif
+  */
+  template<bool _Has_result_type, typename _Signature>
+    struct _Result_of_impl;
+
+  // Handle member data pointers using _Mem_fn's logic
+  template<typename _Res, typename _Class, typename _T1>
+    struct _Result_of_impl<false, _Res _Class::*(_T1)>
+    {
+      typedef typename _Mem_fn<_Res _Class::*>
+                ::template _Result_type<_T1>::type type;
+    };
+
+  /**
+   * @if maint
+   * Determine whether we can determine a result type from @c Functor 
+   * alone.
+   * @endif
+   */ 
+  template<typename _Functor, typename... _ArgTypes>
+    class result_of<_Functor(_ArgTypes...)>
+    : public _Result_of_impl<
+               _Has_result_type<_Weak_result_type<_Functor> >::value,
+               _Functor(_ArgTypes...)>
+    {
+    };
+
+  /**
+   * @if maint
+   * We already know the result type for @c Functor; use it.
+   * @endif
+   */
+  template<typename _Functor, typename... _ArgTypes>
+    struct _Result_of_impl<true, _Functor(_ArgTypes...)>
+    {
+      typedef typename _Weak_result_type<_Functor>::result_type type;
+    };
+
+  /**
+   * @if maint
+   * We need to compute the result type for this invocation the hard 
+   * way.
+   * @endif
+   */
+  template<typename _Functor, typename... _ArgTypes>
+    struct _Result_of_impl<false, _Functor(_ArgTypes...)>
+    {
+      typedef typename _Functor
+                ::template result<_Functor(_ArgTypes...)>::type type;
+    };
+
+  /**
+   * @if maint
+   * It is unsafe to access ::result when there are zero arguments, so we 
+   * return @c void instead.
+   * @endif
+   */
+  template<typename _Functor>
+    struct _Result_of_impl<false, _Functor()>
+    {
+      typedef void type;
+    };
+
+  /**
+   *  @if maint
+   *  Determines if the type _Tp derives from unary_function.
+   *  @endif
+  */
+  template<typename _Tp>
+    struct _Derives_from_unary_function : __sfinae_types
+    {
+    private:
+      template<typename _T1, typename _Res>
+        static __one __test(const volatile unary_function<_T1, _Res>*);
+
+      // It's tempting to change "..." to const volatile void*, but
+      // that fails when _Tp is a function type.
+      static __two __test(...);
+
+    public:
+      static const bool value = sizeof(__test((_Tp*)0)) == 1;
+    };
+
+  /**
+   *  @if maint
+   *  Determines if the type _Tp derives from binary_function.
+   *  @endif
+  */
+  template<typename _Tp>
+    struct _Derives_from_binary_function : __sfinae_types
+    {
+    private:
+      template<typename _T1, typename _T2, typename _Res>
+        static __one __test(const volatile binary_function<_T1, _T2, _Res>*);
+
+      // It's tempting to change "..." to const volatile void*, but
+      // that fails when _Tp is a function type.
+      static __two __test(...);
+
+    public:
+      static const bool value = sizeof(__test((_Tp*)0)) == 1;
+    };
+
+  /**
+   *  @if maint
+   *  Turns a function type into a function pointer type
+   *  @endif
+  */
+  template<typename _Tp, bool _IsFunctionType = is_function<_Tp>::value>
+    struct _Function_to_function_pointer
+    {
+      typedef _Tp type;
+    };
+
+  template<typename _Tp>
+    struct _Function_to_function_pointer<_Tp, true>
+    {
+      typedef _Tp* type;
+    };
+
+  /**
+   * @if maint
+   * Invoke a function object, which may be either a member pointer or a
+   * function object. The first parameter will tell which.
+   * @endif
+   */
+  template<typename _Functor, typename... _Args>
+    inline
+    typename __gnu_cxx::__enable_if<
+             (!is_member_pointer<_Functor>::value
+              && !is_function<_Functor>::value
+              && !is_function<typename remove_pointer<_Functor>::type>::value),
+             typename result_of<_Functor(_Args...)>::type
+           >::__type
+    __invoke(_Functor& __f, _Args&... __args)
+    {
+      return __f(__args...);
+    }
+
+  template<typename _Functor, typename... _Args>
+    inline
+    typename __gnu_cxx::__enable_if<
+             (is_member_pointer<_Functor>::value
+              && !is_function<_Functor>::value
+              && !is_function<typename remove_pointer<_Functor>::type>::value),
+             typename result_of<_Functor(_Args...)>::type
+           >::__type
+    __invoke(_Functor& __f, _Args&... __args)
+    {
+      return mem_fn(__f)(__args...);
+    }
+
+  // To pick up function references (that will become function pointers)
+  template<typename _Functor, typename... _Args>
+    inline
+    typename __gnu_cxx::__enable_if<
+             (is_pointer<_Functor>::value
+              && is_function<typename remove_pointer<_Functor>::type>::value),
+             typename result_of<_Functor(_Args...)>::type
+           >::__type
+    __invoke(_Functor __f, _Args&... __args)
+    {
+      return __f(__args...);
+    }
+
+  /**
+   *  @if maint
+   *  Knowing which of unary_function and binary_function _Tp derives
+   *  from, derives from the same and ensures that reference_wrapper
+   *  will have a weak result type. See cases below.
+   *  @endif
+   */
+  template<bool _Unary, bool _Binary, typename _Tp>
+    struct _Reference_wrapper_base_impl;
+
+  // Not a unary_function or binary_function, so try a weak result type
+  template<typename _Tp>
+    struct _Reference_wrapper_base_impl<false, false, _Tp>
+    : _Weak_result_type<_Tp>
+    { };
+
+  // unary_function but not binary_function
+  template<typename _Tp>
+    struct _Reference_wrapper_base_impl<true, false, _Tp>
+    : unary_function<typename _Tp::argument_type,
+		     typename _Tp::result_type>
+    { };
+
+  // binary_function but not unary_function
+  template<typename _Tp>
+    struct _Reference_wrapper_base_impl<false, true, _Tp>
+    : binary_function<typename _Tp::first_argument_type,
+		      typename _Tp::second_argument_type,
+		      typename _Tp::result_type>
+    { };
+
+  // both unary_function and binary_function. import result_type to
+  // avoid conflicts.
+   template<typename _Tp>
+    struct _Reference_wrapper_base_impl<true, true, _Tp>
+    : unary_function<typename _Tp::argument_type,
+		     typename _Tp::result_type>,
+      binary_function<typename _Tp::first_argument_type,
+		      typename _Tp::second_argument_type,
+		      typename _Tp::result_type>
+    {
+      typedef typename _Tp::result_type result_type;
+    };
+
+  /**
+   *  @if maint
+   *  Derives from unary_function or binary_function when it
+   *  can. Specializations handle all of the easy cases. The primary
+   *  template determines what to do with a class type, which may
+   *  derive from both unary_function and binary_function.
+   *  @endif
+  */
+  template<typename _Tp>
+    struct _Reference_wrapper_base
+    : _Reference_wrapper_base_impl<
+      _Derives_from_unary_function<_Tp>::value,
+      _Derives_from_binary_function<_Tp>::value,
+      _Tp>
+    { };
+
+  // - a function type (unary)
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1)>
+    : unary_function<_T1, _Res>
+    { };
+
+  // - a function type (binary)
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2)>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  // - a function pointer type (unary)
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(*)(_T1)>
+    : unary_function<_T1, _Res>
+    { };
+
+  // - a function pointer type (binary)
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  // - a pointer to member function type (unary, no qualifiers)
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res (_T1::*)()>
+    : unary_function<_T1*, _Res>
+    { };
+
+  // - a pointer to member function type (binary, no qualifiers)
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
+    : binary_function<_T1*, _T2, _Res>
+    { };
+
+  // - a pointer to member function type (unary, const)
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res (_T1::*)() const>
+    : unary_function<const _T1*, _Res>
+    { };
+
+  // - a pointer to member function type (binary, const)
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
+    : binary_function<const _T1*, _T2, _Res>
+    { };
+
+  // - a pointer to member function type (unary, volatile)
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
+    : unary_function<volatile _T1*, _Res>
+    { };
+
+  // - a pointer to member function type (binary, volatile)
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
+    : binary_function<volatile _T1*, _T2, _Res>
+    { };
+
+  // - a pointer to member function type (unary, const volatile)
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
+    : unary_function<const volatile _T1*, _Res>
+    { };
+
+  // - a pointer to member function type (binary, const volatile)
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
+    : binary_function<const volatile _T1*, _T2, _Res>
+    { };
+
+  template<typename _Tp>
+    class reference_wrapper
+    : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
+    {
+      // If _Tp is a function type, we can't form result_of<_Tp(...)>,
+      // so turn it into a function pointer type.
+      typedef typename _Function_to_function_pointer<_Tp>::type
+        _M_func_type;
+
+      _Tp* _M_data;
+    public:
+      typedef _Tp type;
+
+      explicit
+      reference_wrapper(_Tp& __indata): _M_data(&__indata)
+      { }
+
+      reference_wrapper(const reference_wrapper<_Tp>& __inref):
+      _M_data(__inref._M_data)
+      { }
+
+      reference_wrapper&
+      operator=(const reference_wrapper<_Tp>& __inref)
+      {
+        _M_data = __inref._M_data;
+        return *this;
+      }
+
+      operator _Tp&() const
+      { return this->get(); }
+
+      _Tp&
+      get() const
+      { return *_M_data; }
+
+      template<typename... _Args>
+        typename result_of<_M_func_type(_Args...)>::type
+        operator()(_Args&... __args) const
+        {
+	  return __invoke(get(), __args...);
+	}
+    };
+
+
+  // Denotes a reference should be taken to a variable.
+  template<typename _Tp>
+    inline reference_wrapper<_Tp>
+    ref(_Tp& __t)
+    { return reference_wrapper<_Tp>(__t); }
+
+  // Denotes a const reference should be taken to a variable.
+  template<typename _Tp>
+    inline reference_wrapper<const _Tp>
+    cref(const _Tp& __t)
+    { return reference_wrapper<const _Tp>(__t); }
+
+  template<typename _Tp>
+    inline reference_wrapper<_Tp>
+    ref(reference_wrapper<_Tp> __t)
+    { return ref(__t.get()); }
+
+  template<typename _Tp>
+    inline reference_wrapper<const _Tp>
+    cref(reference_wrapper<_Tp> __t)
+    { return cref(__t.get()); }
+
+  template<typename _Tp, bool>
+    struct _Mem_fn_const_or_non
+    {
+      typedef const _Tp& type;
+    };
+
+  template<typename _Tp>
+    struct _Mem_fn_const_or_non<_Tp, false>
+    {
+      typedef _Tp& type;
+    };
+
+  /**
+   * @if maint
+   * Derives from @c unary_function or @c binary_function, or perhaps
+   * nothing, depending on the number of arguments provided. The
+   * primary template is the basis case, which derives nothing.
+   * @endif maint
+   */
+  template<typename _Res, typename... _ArgTypes> 
+    struct _Maybe_unary_or_binary_function { };
+
+  /**
+   * @if maint
+   * Derives from @c unary_function, as appropriate.
+   * @endif
+   */ 
+  template<typename _Res, typename _T1> 
+    struct _Maybe_unary_or_binary_function<_Res, _T1>
+    : std::unary_function<_T1, _Res> { };
+
+  /**
+   * @if maint
+   * Derives from @c binary_function, as appropriate.
+   * @endif
+   */ 
+  template<typename _Res, typename _T1, typename _T2> 
+    struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
+    : std::binary_function<_T1, _T2, _Res> { };
+
+  /**
+   * @if maint
+   * Implementation of @c mem_fn for member function pointers.
+   * @endif
+   */
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    class _Mem_fn<_Res (_Class::*)(_ArgTypes...)>
+    : public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>
+    {
+      typedef _Res (_Class::*_Functor)(_ArgTypes...);
+
+      template<typename _Tp>
+        _Res
+        _M_call(_Tp& __object, const volatile _Class *, 
+                _ArgTypes... __args) const
+        { return (__object.*__pmf)(__args...); }
+
+      template<typename _Tp>
+        _Res
+        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
+        { return ((*__ptr).*__pmf)(__args...); }
+
+    public:
+      typedef _Res result_type;
+
+      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+
+      // Handle objects
+      _Res
+      operator()(_Class& __object, _ArgTypes... __args) const
+      { return (__object.*__pmf)(__args...); }
+
+      // Handle pointers
+      _Res
+      operator()(_Class* __object, _ArgTypes... __args) const
+      { return (__object->*__pmf)(__args...); }
+
+      // Handle smart pointers, references and pointers to derived
+      template<typename _Tp>
+        _Res
+	operator()(_Tp& __object, _ArgTypes... __args) const
+        { return _M_call(__object, &__object, __args...); }
+
+    private:
+      _Functor __pmf;
+    };
+
+  /**
+   * @if maint
+   * Implementation of @c mem_fn for const member function pointers.
+   * @endif
+   */
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const>
+    : public _Maybe_unary_or_binary_function<_Res, const _Class*, 
+					     _ArgTypes...>
+    {
+      typedef _Res (_Class::*_Functor)(_ArgTypes...) const;
+
+      template<typename _Tp>
+        _Res
+        _M_call(_Tp& __object, const volatile _Class *, 
+                _ArgTypes... __args) const
+        { return (__object.*__pmf)(__args...); }
+
+      template<typename _Tp>
+        _Res
+        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
+        { return ((*__ptr).*__pmf)(__args...); }
+
+    public:
+      typedef _Res result_type;
+
+      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+
+      // Handle objects
+      _Res
+      operator()(const _Class& __object, _ArgTypes... __args) const
+      { return (__object.*__pmf)(__args...); }
+
+      // Handle pointers
+      _Res
+      operator()(const _Class* __object, _ArgTypes... __args) const
+      { return (__object->*__pmf)(__args...); }
+
+      // Handle smart pointers, references and pointers to derived
+      template<typename _Tp>
+        _Res operator()(_Tp& __object, _ArgTypes... __args) const
+        { return _M_call(__object, &__object, __args...); }
+
+    private:
+      _Functor __pmf;
+    };
+
+  /**
+   * @if maint
+   * Implementation of @c mem_fn for volatile member function pointers.
+   * @endif
+   */
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile>
+    : public _Maybe_unary_or_binary_function<_Res, volatile _Class*, 
+					     _ArgTypes...>
+    {
+      typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile;
+
+      template<typename _Tp>
+        _Res
+        _M_call(_Tp& __object, const volatile _Class *, 
+                _ArgTypes... __args) const
+        { return (__object.*__pmf)(__args...); }
+
+      template<typename _Tp>
+        _Res
+        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
+        { return ((*__ptr).*__pmf)(__args...); }
+
+    public:
+      typedef _Res result_type;
+
+      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+
+      // Handle objects
+      _Res
+      operator()(volatile _Class& __object, _ArgTypes... __args) const
+      { return (__object.*__pmf)(__args...); }
+
+      // Handle pointers
+      _Res
+      operator()(volatile _Class* __object, _ArgTypes... __args) const
+      { return (__object->*__pmf)(__args...); }
+
+      // Handle smart pointers, references and pointers to derived
+      template<typename _Tp>
+        _Res
+	operator()(_Tp& __object, _ArgTypes... __args) const
+        { return _M_call(__object, &__object, __args...); }
+
+    private:
+      _Functor __pmf;
+    };
+
+  /**
+   * @if maint
+   * Implementation of @c mem_fn for const volatile member function pointers.
+   * @endif
+   */
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile>
+    : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*, 
+					     _ArgTypes...>
+    {
+      typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile;
+
+      template<typename _Tp>
+        _Res
+        _M_call(_Tp& __object, const volatile _Class *, 
+                _ArgTypes... __args) const
+        { return (__object.*__pmf)(__args...); }
+
+      template<typename _Tp>
+        _Res
+        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
+        { return ((*__ptr).*__pmf)(__args...); }
+
+    public:
+      typedef _Res result_type;
+
+      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+
+      // Handle objects
+      _Res 
+      operator()(const volatile _Class& __object, _ArgTypes... __args) const
+      { return (__object.*__pmf)(__args...); }
+
+      // Handle pointers
+      _Res 
+      operator()(const volatile _Class* __object, _ArgTypes... __args) const
+      { return (__object->*__pmf)(__args...); }
+
+      // Handle smart pointers, references and pointers to derived
+      template<typename _Tp>
+        _Res operator()(_Tp& __object, _ArgTypes... __args) const
+        { return _M_call(__object, &__object, __args...); }
+
+    private:
+      _Functor __pmf;
+    };
+
+
+  template<typename _Res, typename _Class>
+    class _Mem_fn<_Res _Class::*>
+    {
+      // This bit of genius is due to Peter Dimov, improved slightly by
+      // Douglas Gregor.
+      template<typename _Tp>
+        _Res&
+        _M_call(_Tp& __object, _Class *) const
+        { return __object.*__pm; }
+
+      template<typename _Tp, typename _Up>
+        _Res&
+        _M_call(_Tp& __object, _Up * const *) const
+        { return (*__object).*__pm; }
+
+      template<typename _Tp, typename _Up>
+        const _Res&
+        _M_call(_Tp& __object, const _Up * const *) const
+        { return (*__object).*__pm; }
+
+      template<typename _Tp>
+        const _Res&
+        _M_call(_Tp& __object, const _Class *) const
+        { return __object.*__pm; }
+
+      template<typename _Tp>
+        const _Res&
+        _M_call(_Tp& __ptr, const volatile void*) const
+        { return (*__ptr).*__pm; }
+
+      template<typename _Tp> static _Tp& __get_ref();
+
+      template<typename _Tp>
+        static __sfinae_types::__one __check_const(_Tp&, _Class*);
+      template<typename _Tp, typename _Up>
+        static __sfinae_types::__one __check_const(_Tp&, _Up * const *);
+      template<typename _Tp, typename _Up>
+        static __sfinae_types::__two __check_const(_Tp&, const _Up * const *);
+      template<typename _Tp>
+        static __sfinae_types::__two __check_const(_Tp&, const _Class*);
+      template<typename _Tp>
+        static __sfinae_types::__two __check_const(_Tp&, const volatile void*);
+
+    public:
+      template<typename _Tp>
+        struct _Result_type
+	: _Mem_fn_const_or_non<_Res,
+	  (sizeof(__sfinae_types::__two)
+	   == sizeof(__check_const<_Tp>(__get_ref<_Tp>(), (_Tp*)0)))>
+        { };
+
+      template<typename _Signature>
+        struct result;
+
+      template<typename _CVMem, typename _Tp>
+        struct result<_CVMem(_Tp)>
+	: public _Result_type<_Tp> { };
+
+      template<typename _CVMem, typename _Tp>
+        struct result<_CVMem(_Tp&)>
+	: public _Result_type<_Tp> { };
+
+      explicit
+      _Mem_fn(_Res _Class::*__pm) : __pm(__pm) { }
+
+      // Handle objects
+      _Res&
+      operator()(_Class& __object) const
+      { return __object.*__pm; }
+
+      const _Res&
+      operator()(const _Class& __object) const
+      { return __object.*__pm; }
+
+      // Handle pointers
+      _Res&
+      operator()(_Class* __object) const
+      { return __object->*__pm; }
+
+      const _Res&
+      operator()(const _Class* __object) const
+      { return __object->*__pm; }
+
+      // Handle smart pointers and derived
+      template<typename _Tp>
+        typename _Result_type<_Tp>::type
+        operator()(_Tp& __unknown) const
+        { return _M_call(__unknown, &__unknown); }
+
+    private:
+      _Res _Class::*__pm;
+    };
+
+  /**
+   *  @brief Returns a function object that forwards to the member
+   *  pointer @a pm.
+   */
+  template<typename _Tp, typename _Class>
+    inline _Mem_fn<_Tp _Class::*>
+    mem_fn(_Tp _Class::* __pm)
+    {
+      return _Mem_fn<_Tp _Class::*>(__pm);
+    }
+
+  /**
+   *  @brief Determines if the given type _Tp is a function object
+   *  should be treated as a subexpression when evaluating calls to
+   *  function objects returned by bind(). [TR1 3.6.1]
+   */
+  template<typename _Tp>
+    struct is_bind_expression
+    { static const bool value = false; };
+
+  template<typename _Tp>
+    const bool is_bind_expression<_Tp>::value;
+
+  /**
+   *  @brief Determines if the given type _Tp is a placeholder in a
+   *  bind() expression and, if so, which placeholder it is. [TR1 3.6.2]
+   */
+  template<typename _Tp>
+    struct is_placeholder
+    { static const int value = 0; };
+
+  template<typename _Tp>
+    const int is_placeholder<_Tp>::value;
+
+  /**
+   *  @if maint
+   *  The type of placeholder objects defined by libstdc++.
+   *  @endif
+   */
+  template<int _Num> struct _Placeholder { };
+
+  // Define a large number of placeholders. There is no way to
+  // simplify this with variadic templates, because we're introducing
+  // unique names for each.
+  namespace placeholders { namespace {
+    _Placeholder<1> _1;
+    _Placeholder<2> _2;
+    _Placeholder<3> _3;
+    _Placeholder<4> _4;
+    _Placeholder<5> _5;
+    _Placeholder<6> _6;
+    _Placeholder<7> _7;
+    _Placeholder<8> _8;
+    _Placeholder<9> _9;
+    _Placeholder<10> _10;
+    _Placeholder<11> _11;
+    _Placeholder<12> _12;
+    _Placeholder<13> _13;
+    _Placeholder<14> _14;
+    _Placeholder<15> _15;
+    _Placeholder<16> _16;
+    _Placeholder<17> _17;
+    _Placeholder<18> _18;
+    _Placeholder<19> _19;
+    _Placeholder<20> _20;
+    _Placeholder<21> _21;
+    _Placeholder<22> _22;
+    _Placeholder<23> _23;
+    _Placeholder<24> _24;
+    _Placeholder<25> _25;
+    _Placeholder<26> _26;
+    _Placeholder<27> _27;
+    _Placeholder<28> _28;
+    _Placeholder<29> _29;
+  } }
+
+  /**
+   *  @if maint
+   *  Partial specialization of is_placeholder that provides the placeholder
+   *  number for the placeholder objects defined by libstdc++.
+   *  @endif
+   */
+  template<int _Num>
+    struct is_placeholder<_Placeholder<_Num> >
+    { static const int value = _Num; };
+
+  template<int _Num>
+    const int is_placeholder<_Placeholder<_Num> >::value;
+
+  /**
+   * @if maint
+   * Stores a tuple of indices. Used by bind() to extract the elements
+   * in a tuple. 
+   * @endif
+   */
+  template<int... _Indexes>
+    struct _Index_tuple { };
+
+  /**
+   *  @if maint
+   *  Builds an _Index_tuple<0, 1, 2, ..., _Num-1>.
+   *  @endif
+   */
+  template<std::size_t _Num, typename _Tuple = _Index_tuple<> >
+    struct _Build_index_tuple;
+ 
+  template<std::size_t _Num, int... _Indexes> 
+    struct _Build_index_tuple<_Num, _Index_tuple<_Indexes...> >
+    : _Build_index_tuple<_Num - 1, 
+                         _Index_tuple<_Indexes..., sizeof...(_Indexes)> >
+    {
+    };
+
+  template<int... _Indexes>
+    struct _Build_index_tuple<0, _Index_tuple<_Indexes...> >
+    {
+      typedef _Index_tuple<_Indexes...> __type;
+    };
+
+  /** 
+   * @if maint
+   * Used by _Safe_tuple_element to indicate that there is no tuple
+   * element at this position.
+   * @endif
+   */
+  struct _No_tuple_element;
+
+  /**
+   * @if maint
+   * Implementation helper for _Safe_tuple_element. This primary
+   * template handles the case where it is safe to use @c
+   * tuple_element.
+   * @endif
+   */
+  template<int __i, typename _Tuple, bool _IsSafe>
+    struct _Safe_tuple_element_impl
+    : tuple_element<__i, _Tuple> { };
+
+  /**
+   * @if maint
+   * Implementation helper for _Safe_tuple_element. This partial
+   * specialization handles the case where it is not safe to use @c
+   * tuple_element. We just return @c _No_tuple_element.
+   * @endif
+   */
+  template<int __i, typename _Tuple>
+    struct _Safe_tuple_element_impl<__i, _Tuple, false>
+    {
+      typedef _No_tuple_element type;
+    };
+
+  /**
+   * Like tuple_element, but returns @c _No_tuple_element when
+   * tuple_element would return an error.
+   */
+ template<int __i, typename _Tuple>
+   struct _Safe_tuple_element
+   : _Safe_tuple_element_impl<__i, _Tuple, 
+                              (__i >= 0 && __i < tuple_size<_Tuple>::value)>
+   {
+   };
+
+  /**
+   *  @if maint
+   *  Maps an argument to bind() into an actual argument to the bound
+   *  function object [TR1 3.6.3/5]. Only the first parameter should
+   *  be specified: the rest are used to determine among the various
+   *  implementations. Note that, although this class is a function
+   *  object, isn't not entirely normal because it takes only two
+   *  parameters regardless of the number of parameters passed to the
+   *  bind expression. The first parameter is the bound argument and
+   *  the second parameter is a tuple containing references to the
+   *  rest of the arguments.
+   *  @endif
+   */
+  template<typename _Arg,
+           bool _IsBindExp = is_bind_expression<_Arg>::value,
+           bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
+    class _Mu;
+
+  /**
+   *  @if maint
+   *  If the argument is reference_wrapper<_Tp>, returns the
+   *  underlying reference. [TR1 3.6.3/5 bullet 1]
+   *  @endif
+   */
+  template<typename _Tp>
+    class _Mu<reference_wrapper<_Tp>, false, false>
+    {
+    public:
+      typedef _Tp& result_type;
+
+      /* Note: This won't actually work for const volatile
+       * reference_wrappers, because reference_wrapper::get() is const
+       * but not volatile-qualified. This might be a defect in the TR.
+       */
+      template<typename _CVRef, typename _Tuple>
+        result_type
+        operator()(_CVRef& __arg, const _Tuple&) const volatile
+        { return __arg.get(); }
+    };
+
+  /**
+   *  @if maint
+   *  If the argument is a bind expression, we invoke the underlying
+   *  function object with the same cv-qualifiers as we are given and
+   *  pass along all of our arguments (unwrapped). [TR1 3.6.3/5 bullet 2]
+   *  @endif
+   */
+  template<typename _Arg>
+    class _Mu<_Arg, true, false>
+    {
+    public:
+      template<typename _Signature> class result;
+
+      // Determine the result type when we pass the arguments along. This
+      // involves passing along the cv-qualifiers placed on _Mu and
+      // unwrapping the argument bundle.
+      template<typename _CVMu, typename _CVArg, typename... _Args>
+        class result<_CVMu(_CVArg, tuple<_Args...>)>
+	: public result_of<_CVArg(_Args...)> { };
+
+      template<typename _CVArg, typename... _Args>
+        typename result_of<_CVArg(_Args...)>::type
+        operator()(_CVArg& __arg,
+		   const tuple<_Args...>& __tuple) const volatile
+        {
+	  // Construct an index tuple and forward to __call
+	  typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
+	    _Indexes;
+	  return this->__call(__arg, __tuple, _Indexes());
+	}
+
+    private:
+      // Invokes the underlying function object __arg by unpacking all
+      // of the arguments in the tuple. 
+      template<typename _CVArg, typename... _Args, int... _Indexes>
+        typename result_of<_CVArg(_Args...)>::type
+        __call(_CVArg& __arg, const tuple<_Args...>& __tuple,
+	       const _Index_tuple<_Indexes...>&) const volatile
+        {
+	  return __arg(_GLIBCXX_TR1 get<_Indexes>(__tuple)...);
+	}
+    };
+
+  /**
+   *  @if maint
+   *  If the argument is a placeholder for the Nth argument, returns
+   *  a reference to the Nth argument to the bind function object.
+   *  [TR1 3.6.3/5 bullet 3]
+   *  @endif
+   */
+  template<typename _Arg>
+    class _Mu<_Arg, false, true>
+    {
+    public:
+      template<typename _Signature> class result;
+
+      template<typename _CVMu, typename _CVArg, typename _Tuple>
+        class result<_CVMu(_CVArg, _Tuple)>
+        {
+	  // Add a reference, if it hasn't already been done for us.
+	  // This allows us to be a little bit sloppy in constructing
+	  // the tuple that we pass to result_of<...>.
+	  typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value
+						- 1), _Tuple>::type
+	    __base_type;
+
+	public:
+	  typedef typename add_reference<__base_type>::type type;
+	};
+
+      template<typename _Tuple>
+        typename result<_Mu(_Arg, _Tuple)>::type
+        operator()(const volatile _Arg&, const _Tuple& __tuple) const volatile
+        {
+	  return ::std::_GLIBCXX_TR1 get<(is_placeholder<_Arg>::value
+					  - 1)>(__tuple);
+	}
+    };
+
+  /**
+   *  @if maint
+   *  If the argument is just a value, returns a reference to that
+   *  value. The cv-qualifiers on the reference are the same as the
+   *  cv-qualifiers on the _Mu object. [TR1 3.6.3/5 bullet 4]
+   *  @endif
+   */
+  template<typename _Arg>
+    class _Mu<_Arg, false, false>
+    {
+    public:
+      template<typename _Signature> struct result;
+
+      template<typename _CVMu, typename _CVArg, typename _Tuple>
+        struct result<_CVMu(_CVArg, _Tuple)>
+        {
+	  typedef typename add_reference<_CVArg>::type type;
+	};
+
+      // Pick up the cv-qualifiers of the argument
+      template<typename _CVArg, typename _Tuple>
+        _CVArg&
+        operator()(_CVArg& __arg, const _Tuple&) const volatile
+        { return __arg; }
+    };
+
+  /**
+   *  @if maint
+   *  Maps member pointers into instances of _Mem_fn but leaves all
+   *  other function objects untouched. Used by tr1::bind(). The
+   *  primary template handles the non--member-pointer case.
+   *  @endif
+   */
+  template<typename _Tp>
+    struct _Maybe_wrap_member_pointer
+    {
+      typedef _Tp type;
+      
+      static const _Tp&
+      __do_wrap(const _Tp& __x)
+      { return __x; }
+    };
+
+  /**
+   *  @if maint
+   *  Maps member pointers into instances of _Mem_fn but leaves all
+   *  other function objects untouched. Used by tr1::bind(). This
+   *  partial specialization handles the member pointer case.
+   *  @endif
+   */
+  template<typename _Tp, typename _Class>
+    struct _Maybe_wrap_member_pointer<_Tp _Class::*>
+    {
+      typedef _Mem_fn<_Tp _Class::*> type;
+      
+      static type
+      __do_wrap(_Tp _Class::* __pm)
+      { return type(__pm); }
+    };
+
+  /**
+   *  @if maint
+   *  Type of the function object returned from bind().
+   *  @endif
+   */
+  template<typename _Signature>
+    struct _Bind;
+
+   template<typename _Functor, typename... _Bound_args>
+    class _Bind<_Functor(_Bound_args...)>
+    : public _Weak_result_type<_Functor>
+    {
+      typedef _Bind __self_type;
+      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type 
+        _Bound_indexes;
+
+      _Functor _M_f;
+      tuple<_Bound_args...> _M_bound_args;
+
+      // Call unqualified
+      template<typename... _Args, int... _Indexes>
+        typename result_of<
+                   _Functor(typename result_of<_Mu<_Bound_args> 
+                            (_Bound_args, tuple<_Args...>)>::type...)
+                 >::type
+        __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>)
+        {
+          return _M_f(_Mu<_Bound_args>()
+                      (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
+        }
+
+      // Call as const
+      template<typename... _Args, int... _Indexes>
+        typename result_of<
+                   const _Functor(typename result_of<_Mu<_Bound_args> 
+                                    (const _Bound_args, tuple<_Args...>)
+                                  >::type...)>::type
+        __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const
+        {
+          return _M_f(_Mu<_Bound_args>()
+                      (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
+        }
+
+      // Call as volatile
+      template<typename... _Args, int... _Indexes>
+        typename result_of<
+                   volatile _Functor(typename result_of<_Mu<_Bound_args> 
+                                    (volatile _Bound_args, tuple<_Args...>)
+                                  >::type...)>::type
+        __call(const tuple<_Args...>& __args, 
+               _Index_tuple<_Indexes...>) volatile
+        {
+          return _M_f(_Mu<_Bound_args>()
+                      (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
+        }
+
+      // Call as const volatile
+      template<typename... _Args, int... _Indexes>
+        typename result_of<
+                   const volatile _Functor(typename result_of<_Mu<_Bound_args> 
+                                    (const volatile _Bound_args, 
+                                     tuple<_Args...>)
+                                  >::type...)>::type
+        __call(const tuple<_Args...>& __args, 
+               _Index_tuple<_Indexes...>) const volatile
+        {
+          return _M_f(_Mu<_Bound_args>()
+                      (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
+        }
+
+     public:
+      explicit _Bind(_Functor __f, _Bound_args... __bound_args)
+        : _M_f(__f), _M_bound_args(__bound_args...) { }
+
+      // Call unqualified
+      template<typename... _Args>
+        typename result_of<
+                   _Functor(typename result_of<_Mu<_Bound_args> 
+                            (_Bound_args, tuple<_Args...>)>::type...)
+                 >::type
+        operator()(_Args&... __args)
+        {
+          return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
+        }
+
+      // Call as const
+      template<typename... _Args>
+        typename result_of<
+                   const _Functor(typename result_of<_Mu<_Bound_args> 
+                            (const _Bound_args, tuple<_Args...>)>::type...)
+                 >::type
+        operator()(_Args&... __args) const
+        {
+          return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
+        }
+
+
+      // Call as volatile
+      template<typename... _Args>
+        typename result_of<
+                   volatile _Functor(typename result_of<_Mu<_Bound_args> 
+                            (volatile _Bound_args, tuple<_Args...>)>::type...)
+                 >::type
+        operator()(_Args&... __args) volatile
+        {
+          return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
+        }
+
+
+      // Call as const volatile
+      template<typename... _Args>
+        typename result_of<
+                   const volatile _Functor(typename result_of<_Mu<_Bound_args> 
+                            (const volatile _Bound_args, 
+                             tuple<_Args...>)>::type...)
+                 >::type
+        operator()(_Args&... __args) const volatile
+        {
+          return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
+        }
+    };
+
+  /**
+   *  @if maint
+   *  Type of the function object returned from bind<R>().
+   *  @endif
+   */
+  template<typename _Result, typename _Signature>
+    struct _Bind_result;
+
+  template<typename _Result, typename _Functor, typename... _Bound_args>
+    class _Bind_result<_Result, _Functor(_Bound_args...)>
+    {
+      typedef _Bind_result __self_type;
+      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type 
+        _Bound_indexes;
+
+      _Functor _M_f;
+      tuple<_Bound_args...> _M_bound_args;
+
+      // Call unqualified
+      template<typename... _Args, int... _Indexes>
+        _Result
+        __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>)
+        {
+          return _M_f(_Mu<_Bound_args>()
+                      (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
+        }
+
+      // Call as const
+      template<typename... _Args, int... _Indexes>
+        _Result
+        __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const
+        {
+          return _M_f(_Mu<_Bound_args>()
+                      (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
+        }
+
+      // Call as volatile
+      template<typename... _Args, int... _Indexes>
+        _Result
+        __call(const tuple<_Args...>& __args, 
+               _Index_tuple<_Indexes...>) volatile
+        {
+          return _M_f(_Mu<_Bound_args>()
+                      (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
+        }
+
+      // Call as const volatile
+      template<typename... _Args, int... _Indexes>
+        _Result
+        __call(const tuple<_Args...>& __args, 
+               _Index_tuple<_Indexes...>) const volatile
+        {
+          return _M_f(_Mu<_Bound_args>()
+                      (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
+        }
+
+    public:
+      typedef _Result result_type;
+
+      explicit
+      _Bind_result(_Functor __f, _Bound_args... __bound_args)
+      : _M_f(__f), _M_bound_args(__bound_args...) { }
+
+      // Call unqualified
+      template<typename... _Args>
+        result_type
+        operator()(_Args&... __args)
+        {
+          return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
+        }
+
+      // Call as const
+      template<typename... _Args>
+        result_type
+        operator()(_Args&... __args) const
+        {
+          return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
+        }
+
+      // Call as volatile
+      template<typename... _Args>
+        result_type
+        operator()(_Args&... __args) volatile
+        {
+          return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
+        }
+
+      // Call as const volatile
+      template<typename... _Args>
+        result_type
+        operator()(_Args&... __args) const volatile
+        {
+          return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
+        }
+    };
+
+  /**
+   *  @if maint
+   *  Class template _Bind is always a bind expression.
+   *  @endif
+   */
+  template<typename _Signature>
+    struct is_bind_expression<_Bind<_Signature> >
+    { static const bool value = true; };
+
+  template<typename _Signature>
+    const bool is_bind_expression<_Bind<_Signature> >::value;
+
+  /**
+   *  @if maint
+   *  Class template _Bind_result is always a bind expression.
+   *  @endif
+   */
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<_Bind_result<_Result, _Signature> >
+    { static const bool value = true; };
+
+  template<typename _Result, typename _Signature>
+    const bool is_bind_expression<_Bind_result<_Result, _Signature> >::value;
+
+  template<typename _Functor, typename... _ArgTypes>
+    inline
+    _Bind<typename _Maybe_wrap_member_pointer<_Functor>::type(_ArgTypes...)>
+    bind(_Functor __f, _ArgTypes... __args)
+    {
+      typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type;
+      typedef typename __maybe_type::type __functor_type;
+      typedef _Bind<__functor_type(_ArgTypes...)> __result_type;
+      return __result_type(__maybe_type::__do_wrap(__f), __args...);
+    } 
+
+  template<typename _Result, typename _Functor, typename... _ArgTypes>
+    inline
+    _Bind_result<_Result,
+		 typename _Maybe_wrap_member_pointer<_Functor>::type
+                            (_ArgTypes...)>
+    bind(_Functor __f, _ArgTypes... __args)
+    {
+      typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type;
+      typedef typename __maybe_type::type __functor_type;
+      typedef _Bind_result<_Result, __functor_type(_ArgTypes...)>
+	__result_type;
+      return __result_type(__maybe_type::__do_wrap(__f), __args...);
+    }
+
+  /**
+   *  @brief Exception class thrown when class template function's
+   *  operator() is called with an empty target.
+   *
+   */
+  class bad_function_call : public std::exception { };
+
+  /**
+   *  @if maint
+   *  The integral constant expression 0 can be converted into a
+   *  pointer to this type. It is used by the function template to
+   *  accept NULL pointers.
+   *  @endif
+   */
+  struct _M_clear_type;
+
+  /**
+   *  @if maint
+   *  Trait identifying "location-invariant" types, meaning that the
+   *  address of the object (or any of its members) will not escape.
+   *  Also implies a trivial copy constructor and assignment operator.
+   *   @endif
+   */
+  template<typename _Tp>
+    struct __is_location_invariant
+    : integral_constant<bool,
+                        (is_pointer<_Tp>::value
+                         || is_member_pointer<_Tp>::value)>
+    {
+    };
+
+  class _Undefined_class;
+
+  union _Nocopy_types
+  {
+    void*       _M_object;
+    const void* _M_const_object;
+    void (*_M_function_pointer)();
+    void (_Undefined_class::*_M_member_pointer)();
+  };
+
+  union _Any_data
+  {
+    void*       _M_access()       { return &_M_pod_data[0]; }
+    const void* _M_access() const { return &_M_pod_data[0]; }
+
+    template<typename _Tp>
+      _Tp&
+      _M_access()
+      { return *static_cast<_Tp*>(_M_access()); }
+
+    template<typename _Tp>
+      const _Tp&
+      _M_access() const
+      { return *static_cast<const _Tp*>(_M_access()); }
+
+    _Nocopy_types _M_unused;
+    char _M_pod_data[sizeof(_Nocopy_types)];
+  };
+
+  enum _Manager_operation
+  {
+    __get_type_info,
+    __get_functor_ptr,
+    __clone_functor,
+    __destroy_functor
+  };
+
+  /* Simple type wrapper that helps avoid annoying const problems
+     when casting between void pointers and pointers-to-pointers. */
+  template<typename _Tp>
+    struct _Simple_type_wrapper
+    {
+      _Simple_type_wrapper(_Tp __value) : __value(__value) { }
+
+      _Tp __value;
+    };
+
+  template<typename _Tp>
+    struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
+    : __is_location_invariant<_Tp>
+    {
+    };
+
+  // Converts a reference to a function object into a callable
+  // function object.
+  template<typename _Functor>
+    inline _Functor&
+    __callable_functor(_Functor& __f)
+    { return __f; }
+
+  template<typename _Member, typename _Class>
+    inline _Mem_fn<_Member _Class::*>
+    __callable_functor(_Member _Class::* &__p)
+    { return mem_fn(__p); }
+
+  template<typename _Member, typename _Class>
+    inline _Mem_fn<_Member _Class::*>
+    __callable_functor(_Member _Class::* const &__p)
+    { return mem_fn(__p); }
+
+  template<typename _Signature>
+    class function;
+
+  /**
+   *  @if maint
+   *  Base class of all polymorphic function object wrappers.
+   *  @endif
+   */
+  class _Function_base
+  {
+  public:
+    static const std::size_t _M_max_size = sizeof(_Nocopy_types);
+    static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
+
+    template<typename _Functor>
+      class _Base_manager
+      {
+      protected:
+	static const bool __stored_locally =
+        (__is_location_invariant<_Functor>::value
+         && sizeof(_Functor) <= _M_max_size
+         && __alignof__(_Functor) <= _M_max_align
+         && (_M_max_align % __alignof__(_Functor) == 0));
+	
+	typedef integral_constant<bool, __stored_locally> _Local_storage;
+
+	// Retrieve a pointer to the function object
+	static _Functor*
+	_M_get_pointer(const _Any_data& __source)
+	{
+	  const _Functor* __ptr =
+	    __stored_locally? &__source._M_access<_Functor>()
+	    /* have stored a pointer */ : __source._M_access<_Functor*>();
+	  return const_cast<_Functor*>(__ptr);
+	}
+
+	// Clone a location-invariant function object that fits within
+	// an _Any_data structure.
+	static void
+	_M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
+	{
+	  new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
+	}
+
+	// Clone a function object that is not location-invariant or
+	// that cannot fit into an _Any_data structure.
+	static void
+	_M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
+	{
+	  __dest._M_access<_Functor*>() =
+	    new _Functor(*__source._M_access<_Functor*>());
+	}
+
+	// Destroying a location-invariant object may still require
+	// destruction.
+	static void
+	_M_destroy(_Any_data& __victim, true_type)
+	{
+	  __victim._M_access<_Functor>().~_Functor();
+	}
+	
+	// Destroying an object located on the heap.
+	static void
+	_M_destroy(_Any_data& __victim, false_type)
+	{
+	  delete __victim._M_access<_Functor*>();
+	}
+	
+      public:
+	static bool
+	_M_manager(_Any_data& __dest, const _Any_data& __source,
+		   _Manager_operation __op)
+	{
+	  switch (__op)
+	    {
+	    case __get_type_info:
+	      __dest._M_access<const type_info*>() = &typeid(_Functor);
+	      break;
+
+	    case __get_functor_ptr:
+	      __dest._M_access<_Functor*>() = _M_get_pointer(__source);
+	      break;
+	      
+	    case __clone_functor:
+	      _M_clone(__dest, __source, _Local_storage());
+	      break;
+
+	    case __destroy_functor:
+	      _M_destroy(__dest, _Local_storage());
+	      break;
+	    }
+	  return false;
+	}
+
+	static void
+	_M_init_functor(_Any_data& __functor, const _Functor& __f)
+	{
+	  _M_init_functor(__functor, __f, _Local_storage());
+	}
+	
+	template<typename _Signature>
+	  static bool
+	  _M_not_empty_function(const function<_Signature>& __f)
+	  {
+	    return __f;
+	  }
+
+	template<typename _Tp>
+	  static bool
+	  _M_not_empty_function(const _Tp*& __fp)
+	  {
+	    return __fp;
+	  }
+
+	template<typename _Class, typename _Tp>
+	  static bool
+	  _M_not_empty_function(_Tp _Class::* const& __mp)
+	  {
+	    return __mp;
+	  }
+
+	template<typename _Tp>
+	  static bool
+	  _M_not_empty_function(const _Tp&)
+	  {
+	    return true;
+	  }
+
+      private:
+	static void
+	_M_init_functor(_Any_data& __functor, const _Functor& __f, true_type)
+	{
+	  new (__functor._M_access()) _Functor(__f);
+	}
+
+	static void
+	_M_init_functor(_Any_data& __functor, const _Functor& __f, false_type)
+	{
+	  __functor._M_access<_Functor*>() = new _Functor(__f);
+	}
+      };
+
+    template<typename _Functor>
+      class _Ref_manager : public _Base_manager<_Functor*>
+      {
+	typedef _Function_base::_Base_manager<_Functor*> _Base;
+
+    public:
+	static bool
+	_M_manager(_Any_data& __dest, const _Any_data& __source,
+		   _Manager_operation __op)
+	{
+	  switch (__op)
+	    {
+	    case __get_type_info:
+	      __dest._M_access<const type_info*>() = &typeid(_Functor);
+	      break;
+	      
+	    case __get_functor_ptr:
+	      __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
+	      return is_const<_Functor>::value;
+	      break;
+	      
+	    default:
+	      _Base::_M_manager(__dest, __source, __op);
+	    }
+	  return false;
+	}
+
+	static void
+	_M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
+	{
+	  // TBD: Use address_of function instead
+	  _Base::_M_init_functor(__functor, &__f.get());
+	}
+      };
+
+    _Function_base() : _M_manager(0) { }
+    
+    ~_Function_base()
+    {
+      if (_M_manager)
+	_M_manager(_M_functor, _M_functor, __destroy_functor);
+    }
+
+
+    bool _M_empty() const { return !_M_manager; }
+
+    typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
+                                  _Manager_operation);
+
+    _Any_data     _M_functor;
+    _Manager_type _M_manager;
+  };
+
+  template<typename _Signature, typename _Functor>
+    class _Function_handler;
+
+  template<typename _Res, typename _Functor, typename... _ArgTypes>
+    class _Function_handler<_Res(_ArgTypes...), _Functor>
+    : public _Function_base::_Base_manager<_Functor>
+    {
+      typedef _Function_base::_Base_manager<_Functor> _Base;
+
+    public:
+      static _Res
+      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+      {
+        return (*_Base::_M_get_pointer(__functor))(__args...);
+      }
+    };
+
+  template<typename _Functor, typename... _ArgTypes>
+    class _Function_handler<void(_ArgTypes...), _Functor>
+    : public _Function_base::_Base_manager<_Functor>
+    {
+      typedef _Function_base::_Base_manager<_Functor> _Base;
+
+     public:
+      static void
+      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+      {
+        (*_Base::_M_get_pointer(__functor))(__args...);
+      }
+    };
+
+  template<typename _Res, typename _Functor, typename... _ArgTypes>
+    class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
+    : public _Function_base::_Ref_manager<_Functor>
+    {
+      typedef _Function_base::_Ref_manager<_Functor> _Base;
+
+     public:
+      static _Res
+      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+      {
+        return 
+          __callable_functor(**_Base::_M_get_pointer(__functor))(__args...);
+      }
+    };
+
+  template<typename _Functor, typename... _ArgTypes>
+    class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
+    : public _Function_base::_Ref_manager<_Functor>
+    {
+      typedef _Function_base::_Ref_manager<_Functor> _Base;
+
+     public:
+      static void
+      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+      {
+        __callable_functor(**_Base::_M_get_pointer(__functor))(__args...);
+      }
+    };
+
+  template<typename _Class, typename _Member, typename _Res, 
+           typename... _ArgTypes>
+    class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
+    : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
+    {
+      typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
+        _Base;
+
+     public:
+      static _Res
+      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+      {
+        return _GLIBCXX_TR1
+	  mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...);
+      }
+    };
+
+  template<typename _Class, typename _Member, typename... _ArgTypes>
+    class _Function_handler<void(_ArgTypes...), _Member _Class::*>
+    : public _Function_base::_Base_manager<
+                 _Simple_type_wrapper< _Member _Class::* > >
+    {
+      typedef _Member _Class::* _Functor;
+      typedef _Simple_type_wrapper<_Functor> _Wrapper;
+      typedef _Function_base::_Base_manager<_Wrapper> _Base;
+
+     public:
+      static bool
+      _M_manager(_Any_data& __dest, const _Any_data& __source,
+                 _Manager_operation __op)
+      {
+        switch (__op)
+	  {
+	  case __get_type_info:
+	    __dest._M_access<const type_info*>() = &typeid(_Functor);
+	    break;
+	    
+	  case __get_functor_ptr:
+	    __dest._M_access<_Functor*>() =
+	      &_Base::_M_get_pointer(__source)->__value;
+	    break;
+	    
+	  default:
+	    _Base::_M_manager(__dest, __source, __op);
+	  }
+        return false;
+      }
+
+      static void
+      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+      {
+        _GLIBCXX_TR1
+	  mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...);
+      }
+    };
+
+  template<typename _Res, typename... _ArgTypes>
+    class function<_Res(_ArgTypes...)>
+    : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
+      private _Function_base
+    {
+      /**
+       *  @if maint
+       *  This class is used to implement the safe_bool idiom.
+       *  @endif
+       */
+      struct _Hidden_type
+      {
+	_Hidden_type* _M_bool;
+      };
+
+      /**
+       *  @if maint
+       *  This typedef is used to implement the safe_bool idiom.
+       *  @endif
+       */
+      typedef _Hidden_type* _Hidden_type::* _Safe_bool;
+
+      typedef _Res _Signature_type(_ArgTypes...);
+      
+      struct _Useless {};
+      
+    public:
+      typedef _Res result_type;
+      
+      // [3.7.2.1] construct/copy/destroy
+      
+      /**
+       *  @brief Default construct creates an empty function call wrapper.
+       *  @post @c !(bool)*this
+       */
+      function() : _Function_base() { }
+      
+      /**
+       *  @brief Default construct creates an empty function call wrapper.
+       *  @post @c !(bool)*this
+       */
+      function(_M_clear_type*) : _Function_base() { }
+      
+      /**
+       *  @brief %Function copy constructor.
+       *  @param x A %function object with identical call signature.
+       *  @pre @c (bool)*this == (bool)x
+       *
+       *  The newly-created %function contains a copy of the target of @a
+       *  x (if it has one).
+       */
+      function(const function& __x);
+      
+      /**
+       *  @brief Builds a %function that targets a copy of the incoming
+       *  function object.
+       *  @param f A %function object that is callable with parameters of
+       *  type @c T1, @c T2, ..., @c TN and returns a value convertible
+       *  to @c Res.
+       *
+       *  The newly-created %function object will target a copy of @a
+       *  f. If @a f is @c reference_wrapper<F>, then this function
+       *  object will contain a reference to the function object @c
+       *  f.get(). If @a f is a NULL function pointer or NULL
+       *  pointer-to-member, the newly-created object will be empty.
+       *
+       *  If @a f is a non-NULL function pointer or an object of type @c
+       *  reference_wrapper<F>, this function will not throw.
+       */
+      template<typename _Functor>
+        function(_Functor __f,
+                 typename __gnu_cxx::__enable_if<
+                           !is_integral<_Functor>::value, _Useless>::__type
+                   = _Useless());
+
+      /**
+       *  @brief %Function assignment operator.
+       *  @param x A %function with identical call signature.
+       *  @post @c (bool)*this == (bool)x
+       *  @returns @c *this
+       *
+       *  The target of @a x is copied to @c *this. If @a x has no
+       *  target, then @c *this will be empty.
+       *
+       *  If @a x targets a function pointer or a reference to a function
+       *  object, then this operation will not throw an exception.
+       */
+      function&
+      operator=(const function& __x)
+      {
+        function(__x).swap(*this);
+        return *this;
+      }
+
+      /**
+       *  @brief %Function assignment to zero.
+       *  @post @c !(bool)*this
+       *  @returns @c *this
+       *
+       *  The target of @a *this is deallocated, leaving it empty.
+       */
+      function&
+      operator=(_M_clear_type*)
+      {
+        if (_M_manager)
+	  {
+	    _M_manager(_M_functor, _M_functor, __destroy_functor);
+	    _M_manager = 0;
+	    _M_invoker = 0;
+	  }
+        return *this;
+      }
+
+      /**
+       *  @brief %Function assignment to a new target.
+       *  @param f A %function object that is callable with parameters of
+       *  type @c T1, @c T2, ..., @c TN and returns a value convertible
+       *  to @c Res.
+       *  @return @c *this
+       *
+       *  This  %function object wrapper will target a copy of @a
+       *  f. If @a f is @c reference_wrapper<F>, then this function
+       *  object will contain a reference to the function object @c
+       *  f.get(). If @a f is a NULL function pointer or NULL
+       *  pointer-to-member, @c this object will be empty.
+       *
+       *  If @a f is a non-NULL function pointer or an object of type @c
+       *  reference_wrapper<F>, this function will not throw.
+       */
+      template<typename _Functor>
+        typename __gnu_cxx::__enable_if<!is_integral<_Functor>::value,
+	                                function&>::__type
+	operator=(_Functor __f)
+	{
+	  function(__f).swap(*this);
+	  return *this;
+	}
+
+      // [3.7.2.2] function modifiers
+      
+      /**
+       *  @brief Swap the targets of two %function objects.
+       *  @param f A %function with identical call signature.
+       *
+       *  Swap the targets of @c this function object and @a f. This
+       *  function will not throw an exception.
+       */
+      void swap(function& __x)
+      {
+	_Any_data __old_functor = _M_functor;
+	_M_functor = __x._M_functor;
+	__x._M_functor = __old_functor;
+	_Manager_type __old_manager = _M_manager;
+	_M_manager = __x._M_manager;
+	__x._M_manager = __old_manager;
+	_Invoker_type __old_invoker = _M_invoker;
+	_M_invoker = __x._M_invoker;
+	__x._M_invoker = __old_invoker;
+      }
+      
+      // [3.7.2.3] function capacity
+
+      /**
+       *  @brief Determine if the %function wrapper has a target.
+       *
+       *  @return @c true when this %function object contains a target,
+       *  or @c false when it is empty.
+       *
+       *  This function will not throw an exception.
+       */
+      operator _Safe_bool() const
+      {
+        if (_M_empty())
+	  return 0;
+	else
+	  return &_Hidden_type::_M_bool;
+      }
+
+      // [3.7.2.4] function invocation
+
+      /**
+       *  @brief Invokes the function targeted by @c *this.
+       *  @returns the result of the target.
+       *  @throws bad_function_call when @c !(bool)*this
+       *
+       *  The function call operator invokes the target function object
+       *  stored by @c this.
+       */
+      _Res operator()(_ArgTypes... __args) const;
+      
+      // [3.7.2.5] function target access
+      /**
+       *  @brief Determine the type of the target of this function object
+       *  wrapper.
+       *
+       *  @returns the type identifier of the target function object, or
+       *  @c typeid(void) if @c !(bool)*this.
+       *
+       *  This function will not throw an exception.
+       */
+      const type_info& target_type() const;
+      
+      /**
+       *  @brief Access the stored target function object.
+       *
+       *  @return Returns a pointer to the stored target function object,
+       *  if @c typeid(Functor).equals(target_type()); otherwise, a NULL
+       *  pointer.
+       *
+       * This function will not throw an exception.
+       */
+      template<typename _Functor>       _Functor* target();
+      
+      /**
+       *  @overload
+       */
+      template<typename _Functor> const _Functor* target() const;
+      
+    private:
+      // [3.7.2.6] undefined operators
+      template<typename _Function>
+	void operator==(const function<_Function>&) const;
+      template<typename _Function>
+	void operator!=(const function<_Function>&) const;
+
+      typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...);
+      _Invoker_type _M_invoker;
+  };
+
+  template<typename _Res, typename... _ArgTypes>
+    function<_Res(_ArgTypes...)>::
+    function(const function& __x)
+    : _Function_base()
+    {
+      if (__x)
+	{
+	  _M_invoker = __x._M_invoker;
+	  _M_manager = __x._M_manager;
+	  __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
+	}
+    }
+
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor>
+      function<_Res(_ArgTypes...)>::
+      function(_Functor __f,
+	       typename __gnu_cxx::__enable_if<
+                       !is_integral<_Functor>::value, _Useless>::__type)
+      : _Function_base()
+      {
+	typedef _Function_handler<_Signature_type, _Functor> _My_handler;
+
+	if (_My_handler::_M_not_empty_function(__f))
+	  {
+	    _M_invoker = &_My_handler::_M_invoke;
+	    _M_manager = &_My_handler::_M_manager;
+	    _My_handler::_M_init_functor(_M_functor, __f);
+	  }
+      }
+
+  template<typename _Res, typename... _ArgTypes>
+    _Res
+    function<_Res(_ArgTypes...)>::
+    operator()(_ArgTypes... __args) const
+    {
+      if (_M_empty())
+        {
+#if __EXCEPTIONS
+          throw bad_function_call();
+#else
+          __builtin_abort();
+#endif
+        }
+      return _M_invoker(_M_functor, __args...);
+    }
+
+  template<typename _Res, typename... _ArgTypes>
+    const type_info&
+    function<_Res(_ArgTypes...)>::
+    target_type() const
+    {
+      if (_M_manager)
+        {
+          _Any_data __typeinfo_result;
+          _M_manager(__typeinfo_result, _M_functor, __get_type_info);
+          return *__typeinfo_result._M_access<const type_info*>();
+        }
+      else
+	return typeid(void);
+    }
+
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor>
+      _Functor*
+      function<_Res(_ArgTypes...)>::
+      target()
+      {
+	if (typeid(_Functor) == target_type() && _M_manager)
+	  {
+	    _Any_data __ptr;
+	    if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
+		&& !is_const<_Functor>::value)
+	      return 0;
+	    else
+	      return __ptr._M_access<_Functor*>();
+	  }
+	else
+	  return 0;
+      }
+
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor>
+      const _Functor*
+      function<_Res(_ArgTypes...)>::
+      target() const
+      {
+	if (typeid(_Functor) == target_type() && _M_manager)
+	  {
+	    _Any_data __ptr;
+	    _M_manager(__ptr, _M_functor, __get_functor_ptr);
+	    return __ptr._M_access<const _Functor*>();
+	  }
+	else
+	  return 0;
+      }
+
+  // [3.7.2.7] null pointer comparisons
+
+  /**
+   *  @brief Compares a polymorphic function object wrapper against 0
+   *  (the NULL pointer).
+   *  @returns @c true if the wrapper has no target, @c false otherwise
+   *
+   *  This function will not throw an exception.
+   */
+  template<typename _Signature>
+    inline bool
+    operator==(const function<_Signature>& __f, _M_clear_type*)
+    { 
+      return !__f;
+    }
+
+  /**
+   *  @overload
+   */
+  template<typename _Signature>
+    inline bool
+    operator==(_M_clear_type*, const function<_Signature>& __f)
+    {
+      return !__f;
+    }
+
+  /**
+   *  @brief Compares a polymorphic function object wrapper against 0
+   *  (the NULL pointer).
+   *  @returns @c false if the wrapper has no target, @c true otherwise
+   *
+   *  This function will not throw an exception.
+   */
+  template<typename _Signature>
+    inline bool
+    operator!=(const function<_Signature>& __f, _M_clear_type*)
+    {
+      return __f;
+    }
+
+  /**
+   *  @overload
+   */
+  template<typename _Signature>
+    inline bool
+    operator!=(_M_clear_type*, const function<_Signature>& __f)
+    {
+      return __f;
+    }
+
+  // [3.7.2.8] specialized algorithms
+
+  /**
+   *  @brief Swap the targets of two polymorphic function object wrappers.
+   *
+   *  This function will not throw an exception.
+   */
+  template<typename _Signature>
+    inline void
+    swap(function<_Signature>& __x, function<_Signature>& __y)
+    {
+      __x.swap(__y);
+    }
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
diff --git a/libstdc++-v3/include/tr1_impl/functional_hash.h b/libstdc++-v3/include/tr1_impl/functional_hash.h
new file mode 100644
index 0000000..3b1a758
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/functional_hash.h
@@ -0,0 +1,223 @@
+// TR1 functional -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/functional_hash.h
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+  // Definition of default hash function std::tr1::hash<>.  The types for
+  // which std::tr1::hash<T> is defined is in clause 6.3.3. of the PDTR.
+  template<typename _Tp>
+    struct hash;
+
+#define _TR1_hashtable_define_trivial_hash(_Tp)         \
+  template<>                                            \
+    struct hash<_Tp>                                    \
+    : public std::unary_function<_Tp, std::size_t>      \
+    {                                                   \
+      std::size_t                                       \
+      operator()(_Tp __val) const                       \
+      { return static_cast<std::size_t>(__val); }       \
+    }                                                     
+
+  _TR1_hashtable_define_trivial_hash(bool);
+  _TR1_hashtable_define_trivial_hash(char);
+  _TR1_hashtable_define_trivial_hash(signed char);
+  _TR1_hashtable_define_trivial_hash(unsigned char);
+  _TR1_hashtable_define_trivial_hash(wchar_t);
+  _TR1_hashtable_define_trivial_hash(short);
+  _TR1_hashtable_define_trivial_hash(int);
+  _TR1_hashtable_define_trivial_hash(long);
+  _TR1_hashtable_define_trivial_hash(long long);
+  _TR1_hashtable_define_trivial_hash(unsigned short);
+  _TR1_hashtable_define_trivial_hash(unsigned int);
+  _TR1_hashtable_define_trivial_hash(unsigned long);
+  _TR1_hashtable_define_trivial_hash(unsigned long long);
+
+#undef _TR1_hashtable_define_trivial_hash
+
+  template<typename _Tp>
+    struct hash<_Tp*>
+    : public std::unary_function<_Tp*, std::size_t>
+    {
+      std::size_t
+      operator()(_Tp* __p) const
+      { return reinterpret_cast<std::size_t>(__p); }
+    };
+
+  // Fowler / Noll / Vo (FNV) Hash (type FNV-1a)
+  // (used by the next specializations of std::tr1::hash<>)
+
+  // Dummy generic implementation (for sizeof(size_t) != 4, 8).
+  template<std::size_t = sizeof(std::size_t)>
+    struct _Fnv_hash
+    {
+      static std::size_t
+      hash(const char* __first, std::size_t __length)
+      {
+	std::size_t __result = 0;
+	for (; __length > 0; --__length)
+	  __result = (__result * 131) + *__first++;
+	return __result;
+      }
+    };
+
+  template<>
+    struct _Fnv_hash<4>
+    {
+      static std::size_t
+      hash(const char* __first, std::size_t __length)
+      {
+	std::size_t __result = static_cast<std::size_t>(2166136261UL);
+	for (; __length > 0; --__length)
+	  {
+	    __result ^= static_cast<std::size_t>(*__first++);
+	    __result *= static_cast<std::size_t>(16777619UL);
+	  }
+	return __result;
+      }
+    };
+  
+  template<>
+    struct _Fnv_hash<8>
+    {
+      static std::size_t
+      hash(const char* __first, std::size_t __length)
+      {
+	std::size_t __result =
+	  static_cast<std::size_t>(14695981039346656037ULL);
+	for (; __length > 0; --__length)
+	  {
+	    __result ^= static_cast<std::size_t>(*__first++);
+	    __result *= static_cast<std::size_t>(1099511628211ULL);
+	  }
+	return __result;
+      }
+    };
+
+  // XXX String and floating point hashes probably shouldn't be inline
+  // member functions, since are nontrivial.  Once we have the framework
+  // for TR1 .cc files, these should go in one.
+  template<>
+    struct hash<std::string>
+    : public std::unary_function<std::string, std::size_t>
+    {      
+      std::size_t
+      operator()(const std::string& __s) const
+      { return _Fnv_hash<>::hash(__s.data(), __s.length()); }
+    };
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<>
+    struct hash<std::wstring>
+    : public std::unary_function<std::wstring, std::size_t>
+    {
+      std::size_t
+      operator()(const std::wstring& __s) const
+      {
+	return _Fnv_hash<>::hash(reinterpret_cast<const char*>(__s.data()),
+				 __s.length() * sizeof(wchar_t));
+      }
+    };
+#endif
+
+  template<>
+    struct hash<float>
+    : public std::unary_function<float, std::size_t>
+    {
+      std::size_t
+      operator()(float __fval) const
+      {
+	std::size_t __result = 0;
+
+	// 0 and -0 both hash to zero.
+	if (__fval != 0.0f)
+	  __result = _Fnv_hash<>::hash(reinterpret_cast<const char*>(&__fval),
+				       sizeof(__fval));
+	return __result;
+      }
+    };
+
+  template<>
+    struct hash<double>
+    : public std::unary_function<double, std::size_t>
+    {
+      std::size_t
+      operator()(double __dval) const
+      {
+	std::size_t __result = 0;
+
+	// 0 and -0 both hash to zero.
+	if (__dval != 0.0)
+	  __result = _Fnv_hash<>::hash(reinterpret_cast<const char*>(&__dval),
+				       sizeof(__dval));
+	return __result;
+      }
+    };
+
+  // For long double, careful with random padding bits (e.g., on x86,
+  // 10 bytes -> 12 bytes) and resort to frexp.
+  template<>
+    struct hash<long double>
+    : public std::unary_function<long double, std::size_t>
+    {
+      std::size_t
+      operator()(long double __ldval) const
+      {
+	std::size_t __result = 0;
+
+	int __exponent;
+	__ldval = std::frexp(__ldval, &__exponent);
+	__ldval = __ldval < 0.0l ? -(__ldval + 0.5l) : __ldval;
+
+	const long double __mult =
+	  __gnu_cxx::__numeric_traits<std::size_t>::__max + 1.0l;
+	__ldval *= __mult;
+
+	// Try to use all the bits of the mantissa (really necessary only
+	// on 32-bit targets, at least for 80-bit floating point formats).
+	const std::size_t __hibits = (std::size_t)__ldval;
+	__ldval = (__ldval - (long double)__hibits) * __mult;
+
+	const std::size_t __coeff =
+	  __gnu_cxx::__numeric_traits<std::size_t>::__max / __LDBL_MAX_EXP__;
+
+	__result = __hibits + (std::size_t)__ldval + __coeff * __exponent;
+
+	return __result;
+      }
+    };
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
diff --git a/libstdc++-v3/include/tr1/hashtable b/libstdc++-v3/include/tr1_impl/hashtable
index 526ebf8..acdeb66 100644
--- a/libstdc++-v3/include/tr1/hashtable
+++ b/libstdc++-v3/include/tr1_impl/hashtable
@@ -1,6 +1,6 @@
 // Internal header for TR1 unordered_set and unordered_map -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -27,8 +27,9 @@
 // invalidate any other reasons why the executable file might be covered by
 // the GNU General Public License.
 
-/** @file tr1/hashtable
- *  This is a TR1 C++ Library header. 
+/** @file tr1_impl/hashtable
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
  */
 
 // This header file defines std::tr1::hashtable, which is used to
@@ -49,22 +50,11 @@
 // A. Tavori and V. Dreizin, "Policy-Based Data Structures", 2004.
 // http://gcc.gnu.org/onlinedocs/libstdc++/ext/pb_ds/index.html
 
-#ifndef _TR1_HASHTABLE
-#define _TR1_HASHTABLE 1
-
-#include <utility>		// For std::pair
-#include <cstddef>
-#include <cmath>
-#include <bits/stl_iterator_base_types.h>
-#include <bits/stl_iterator_base_funcs.h>
-#include <bits/allocator.h>
-#include <bits/functexcept.h>
-#include <tr1/type_traits>	// For true_type and false_type
-#include <tr1/hashtable_policy.h>
+#include <tr1_impl/hashtable_policy.h>
 
 namespace std
 { 
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+_GLIBCXX_BEGIN_NAMESPACE_TR1
 
   // Class template _Hashtable, class definition.
   
@@ -382,10 +372,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 		       typename _Hashtable::_Hash_code_type);
 
       std::pair<iterator, bool>
-      _M_insert(const value_type&, std::_GLIBCXX_TR1::true_type);
+      _M_insert(const value_type&, std::_GLIBCXX_TR1 true_type);
 
       iterator
-      _M_insert(const value_type&, std::_GLIBCXX_TR1::false_type);
+      _M_insert(const value_type&, std::_GLIBCXX_TR1 false_type);
 
       void
       _M_erase_node(_Node*, _Node**);
@@ -394,7 +384,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
       // Insert and erase
       _Insert_Return_Type
       insert(const value_type& __v) 
-      { return _M_insert(__v, std::_GLIBCXX_TR1::integral_constant<bool,
+      { return _M_insert(__v, std::_GLIBCXX_TR1 integral_constant<bool,
 			 __unique_keys>()); }
 
       iterator
@@ -908,7 +898,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 				  __chc, __cit, __uk>::iterator, bool>
     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    _M_insert(const value_type& __v, std::_GLIBCXX_TR1::true_type)
+    _M_insert(const value_type& __v, std::_GLIBCXX_TR1 true_type)
     {
       const key_type& __k = this->_M_extract(__v);
       typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
@@ -929,7 +919,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 			__chc, __cit, __uk>::iterator
     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    _M_insert(const value_type& __v, std::_GLIBCXX_TR1::false_type)
+    _M_insert(const value_type& __v, std::_GLIBCXX_TR1 false_type)
     {
       std::pair<bool, std::size_t> __do_rehash
 	= _M_rehash_policy._M_need_rehash(_M_bucket_count,
@@ -1196,8 +1186,5 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 	}
     }
 
-_GLIBCXX_END_NAMESPACE
-} // namespace std::tr1
-
-#endif // _TR1_HASHTABLE
-
+_GLIBCXX_END_NAMESPACE_TR1
+}
diff --git a/libstdc++-v3/include/tr1/hashtable_policy.h b/libstdc++-v3/include/tr1_impl/hashtable_policy.h
index 270380c..79740fa 100644
--- a/libstdc++-v3/include/tr1/hashtable_policy.h
+++ b/libstdc++-v3/include/tr1_impl/hashtable_policy.h
@@ -1,6 +1,6 @@
 // Internal policy header for TR1 unordered_set and unordered_map -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -27,21 +27,15 @@
 // invalidate any other reasons why the executable file might be covered by
 // the GNU General Public License.
 
-/** @file tr1/hashtable_policy.h
- *  This is a TR1 C++ Library header. 
+/** @file tr1_impl/hashtable_policy.h
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
  */
 
-#ifndef _TR1_HASHTABLE_POLICY_H
-#define _TR1_HASHTABLE_POLICY_H 1
-
-#include <algorithm> // lower_bound
-#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
-#include <tr1/utility>
-#include <ext/type_traits.h>
-
 namespace std
 { 
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
 namespace __detail
 {
   // Helper function: return distance(first, last) for forward
@@ -897,8 +891,6 @@ namespace __detail
       _H2          _M_h2;
     };
 } // namespace __detail
-_GLIBCXX_END_NAMESPACE
-} // namespace std::tr1
-
-#endif // _TR1_HASHTABLE_POLICY_H
 
+_GLIBCXX_END_NAMESPACE_TR1
+}
diff --git a/libstdc++-v3/include/tr1_impl/random b/libstdc++-v3/include/tr1_impl/random
new file mode 100644
index 0000000..8d2b9ee
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/random
@@ -0,0 +1,2349 @@
+// random number generation -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/**
+ * @file tr1_impl/random
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+  // [5.1] Random number generation
+
+  /**
+   * @addtogroup tr1_random Random Number Generation
+   * A facility for generating random numbers on selected distributions.
+   * @{
+   */
+
+  /*
+   * Implementation-space details.
+   */
+  namespace __detail
+  {
+    template<typename _UIntType, int __w, 
+	     bool = __w < std::numeric_limits<_UIntType>::digits>
+      struct _Shift
+      { static const _UIntType __value = 0; };
+
+    template<typename _UIntType, int __w>
+      struct _Shift<_UIntType, __w, true>
+      { static const _UIntType __value = _UIntType(1) << __w; };
+
+    template<typename _Tp, _Tp __a, _Tp __c, _Tp __m, bool>
+      struct _Mod;
+
+    // Dispatch based on modulus value to prevent divide-by-zero compile-time
+    // errors when m == 0.
+    template<typename _Tp, _Tp __a, _Tp __c, _Tp __m>
+      inline _Tp
+      __mod(_Tp __x)
+      { return _Mod<_Tp, __a, __c, __m, __m == 0>::__calc(__x); }
+
+    typedef __gnu_cxx::__conditional_type<(sizeof(unsigned) == 4),
+		    unsigned, unsigned long>::__type _UInt32Type;
+
+    /*
+     * An adaptor class for converting the output of any Generator into
+     * the input for a specific Distribution.
+     */
+    template<typename _Engine, typename _Distribution>
+      struct _Adaptor
+      { 
+	typedef typename _Engine::result_type        _Engine_result_type;
+	typedef typename _Distribution::input_type   result_type;
+
+      public:
+	_Adaptor(const _Engine& __g)
+	: _M_g(__g) { }
+
+	result_type
+	min() const
+	{
+	  result_type __return_value = 0;
+	  if (is_integral<_Engine_result_type>::value
+	      && is_integral<result_type>::value)
+	    __return_value = _M_g.min();
+	  else if (!is_integral<result_type>::value)
+	    __return_value = result_type(0);
+	  return __return_value;
+	}
+
+	result_type
+	max() const
+	{
+	  result_type __return_value = 0;
+	  if (is_integral<_Engine_result_type>::value
+	      && is_integral<result_type>::value)
+	    __return_value = _M_g.max();
+	  else if (!is_integral<result_type>::value)
+	    __return_value = result_type(1);
+	  return __return_value;
+	}
+
+	result_type
+	operator()();
+
+      private:
+	_Engine _M_g;
+      };
+
+    /*
+     * Converts a value generated by the adapted random number generator into a
+     * value in the input domain for the dependent random number distribution.
+     *
+     * Because the type traits are compile time constants only the appropriate
+     * clause of the if statements will actually be emitted by the compiler.
+     */
+    template<typename _Engine, typename _Distribution>
+      typename _Adaptor<_Engine, _Distribution>::result_type
+      _Adaptor<_Engine, _Distribution>::
+      operator()()
+      {
+	result_type __return_value = 0;
+	if (is_integral<_Engine_result_type>::value
+	    && is_integral<result_type>::value)
+	  __return_value = _M_g();
+      	else if (is_integral<_Engine_result_type>::value
+		 && !is_integral<result_type>::value)
+	  __return_value = result_type(_M_g() - _M_g.min())
+	    / result_type(_M_g.max() - _M_g.min() + result_type(1));
+	else if (!is_integral<_Engine_result_type>::value
+		 && !is_integral<result_type>::value)
+	  __return_value = result_type(_M_g() - _M_g.min())
+	    / result_type(_M_g.max() - _M_g.min());
+      	return __return_value;
+      }
+  } // namespace __detail
+
+  /**
+   * Produces random numbers on a given disribution function using a un uniform
+   * random number generation engine.
+   *
+   * @todo the engine_value_type needs to be studied more carefully.
+   */
+  template<typename _Engine, typename _Dist>
+    class variate_generator
+    {
+      // Concept requirements.
+      __glibcxx_class_requires(_Engine, _CopyConstructibleConcept)
+      //  __glibcxx_class_requires(_Engine, _EngineConcept)
+      //  __glibcxx_class_requires(_Dist, _EngineConcept)
+
+    public:
+      typedef _Engine                                engine_type;
+      typedef __detail::_Adaptor<_Engine, _Dist>     engine_value_type;
+      typedef _Dist                                  distribution_type;
+      typedef typename _Dist::result_type            result_type;
+
+      // tr1:5.1.1 table 5.1 requirement
+      typedef typename __gnu_cxx::__enable_if<
+	is_arithmetic<result_type>::value, result_type>::__type _IsValidType;
+
+      /**
+       * Constructs a variate generator with the uniform random number
+       * generator @p __eng for the random distribution @p __dist.
+       *
+       * @throws Any exceptions which may thrown by the copy constructors of
+       * the @p _Engine or @p _Dist objects.
+       */
+      variate_generator(engine_type __eng, distribution_type __dist)
+      : _M_engine(__eng), _M_dist(__dist) { }
+
+      /**
+       * Gets the next generated value on the distribution.
+       */
+      result_type
+      operator()()
+      { return _M_dist(_M_engine); }
+
+      /**
+       * WTF?
+       */
+      template<typename _Tp>
+        result_type
+        operator()(_Tp __value)
+        { return _M_dist(_M_engine, __value); }
+
+      /**
+       * Gets a reference to the underlying uniform random number generator
+       * object.
+       */
+      engine_value_type&
+      engine()
+      { return _M_engine; }
+
+      /**
+       * Gets a const reference to the underlying uniform random number
+       * generator object.
+       */
+      const engine_value_type&
+      engine() const
+      { return _M_engine; }
+
+      /**
+       * Gets a reference to the underlying random distribution.
+       */
+      distribution_type&
+      distribution()
+      { return _M_dist; }
+
+      /**
+       * Gets a const reference to the underlying random distribution.
+       */
+      const distribution_type&
+      distribution() const
+      { return _M_dist; }
+
+      /**
+       * Gets the closed lower bound of the distribution interval.
+       */
+      result_type
+      min() const
+      { return this->distribution().min(); }
+
+      /**
+       * Gets the closed upper bound of the distribution interval.
+       */
+      result_type
+      max() const
+      { return this->distribution().max(); }
+
+    private:
+      engine_value_type _M_engine;
+      distribution_type _M_dist;
+    };
+
+
+  /**
+   * @addtogroup tr1_random_generators Random Number Generators
+   * @ingroup tr1_random
+   *
+   * These classes define objects which provide random or pseudorandom
+   * numbers, either from a discrete or a continuous interval.  The
+   * random number generator supplied as a part of this library are
+   * all uniform random number generators which provide a sequence of
+   * random number uniformly distributed over their range.
+   *
+   * A number generator is a function object with an operator() that
+   * takes zero arguments and returns a number.
+   *
+   * A compliant random number generator must satisy the following
+   * requirements.  <table border=1 cellpadding=10 cellspacing=0>
+   * <caption align=top>Random Number Generator Requirements</caption>
+   * <tr><td>To be documented.</td></tr> </table>
+   * 
+   * @{
+   */
+
+  /**
+   * @brief A model of a linear congruential random number generator.
+   *
+   * A random number generator that produces pseudorandom numbers using the
+   * linear function @f$x_{i+1}\leftarrow(ax_{i} + c) \bmod m @f$.
+   *
+   * The template parameter @p _UIntType must be an unsigned integral type
+   * large enough to store values up to (__m-1). If the template parameter
+   * @p __m is 0, the modulus @p __m used is
+   * std::numeric_limits<_UIntType>::max() plus 1. Otherwise, the template
+   * parameters @p __a and @p __c must be less than @p __m.
+   *
+   * The size of the state is @f$ 1 @f$.
+   */
+  template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+    class linear_congruential
+    {
+      __glibcxx_class_requires(_UIntType, _UnsignedIntegerConcept)
+      //  __glibcpp_class_requires(__a < __m && __c < __m)
+
+    public:
+      /** The type of the generated random value. */
+      typedef _UIntType result_type;
+
+      /** The multiplier. */
+      static const _UIntType multiplier = __a;
+      /** An increment. */
+      static const _UIntType increment = __c;
+      /** The modulus. */
+      static const _UIntType modulus = __m;
+
+      /**
+       * Constructs a %linear_congruential random number generator engine with
+       * seed @p __s.  The default seed value is 1.
+       *
+       * @param __s The initial seed value.
+       */
+      explicit
+      linear_congruential(unsigned long __x0 = 1)
+      { this->seed(__x0); }
+
+      /**
+       * Constructs a %linear_congruential random number generator engine
+       * seeded from the generator function @p __g.
+       *
+       * @param __g The seed generator function.
+       */
+      template<class _Gen>
+        linear_congruential(_Gen& __g)
+        { this->seed(__g); }
+
+      /**
+       * Reseeds the %linear_congruential random number generator engine
+       * sequence to the seed @g __s.
+       *
+       * @param __s The new seed.
+       */
+      void
+      seed(unsigned long __s = 1);
+
+      /**
+       * Reseeds the %linear_congruential random number generator engine
+       * sequence using values from the generator function @p __g.
+       *
+       * @param __g the seed generator function.
+       */
+      template<class _Gen>
+        void
+        seed(_Gen& __g)
+        { seed(__g, typename is_fundamental<_Gen>::type()); }
+
+      /**
+       * Gets the smallest possible value in the output range.
+       *
+       * The minumum depends on the @p __c parameter: if it is zero, the
+       * minimum generated must be > 0, otherwise 0 is allowed.
+       */
+      result_type
+      min() const
+      { return (__detail::__mod<_UIntType, 1, 0, __m>(__c) == 0) ? 1 : 0; }
+
+      /**
+       * Gets the largest possible value in the output range.
+       */
+      result_type
+      max() const
+      { return __m - 1; }
+
+      /**
+       * Gets the next random number in the sequence.
+       */
+      result_type
+      operator()();
+
+      /**
+       * Compares two linear congruential random number generator
+       * objects of the same type for equality.
+       *  
+       * @param __lhs A linear congruential random number generator object.
+       * @param __rhs Another linear congruential random number generator obj.
+       *
+       * @returns true if the two objects are equal, false otherwise.
+       */
+      friend bool
+      operator==(const linear_congruential& __lhs,
+		 const linear_congruential& __rhs)
+      { return __lhs._M_x == __rhs._M_x; }
+
+      /**
+       * Compares two linear congruential random number generator
+       * objects of the same type for inequality.
+       *
+       * @param __lhs A linear congruential random number generator object.
+       * @param __rhs Another linear congruential random number generator obj.
+       *
+       * @returns true if the two objects are not equal, false otherwise.
+       */
+      friend bool
+      operator!=(const linear_congruential& __lhs,
+		 const linear_congruential& __rhs)
+      { return !(__lhs == __rhs); }
+
+      /**
+       * Writes the textual representation of the state x(i) of x to @p __os.
+       *
+       * @param __os  The output stream.
+       * @param __lcr A % linear_congruential random number generator.
+       * @returns __os.
+       */
+      template<class _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
+	       _UIntType1 __m1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const linear_congruential<_UIntType1, __a1, __c1,
+		   __m1>& __lcr);
+
+      /**
+       * Sets the state of the engine by reading its textual
+       * representation from @p __is.
+       *
+       * The textual representation must have been previously written using an
+       * output stream whose imbued locale and whose type's template
+       * specialization arguments _CharT and _Traits were the same as those of
+       * @p __is.
+       *
+       * @param __is  The input stream.
+       * @param __lcr A % linear_congruential random number generator.
+       * @returns __is.
+       */
+      template<class _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
+	       _UIntType1 __m1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   linear_congruential<_UIntType1, __a1, __c1, __m1>& __lcr);
+
+    private:
+      template<class _Gen>
+        void
+        seed(_Gen& __g, true_type)
+        { return seed(static_cast<unsigned long>(__g)); }
+
+      template<class _Gen>
+        void
+        seed(_Gen& __g, false_type);
+
+      _UIntType _M_x;
+    };
+
+  /**
+   * The classic Minimum Standard rand0 of Lewis, Goodman, and Miller.
+   */
+  typedef linear_congruential<unsigned long, 16807, 0, 2147483647> minstd_rand0;
+
+  /**
+   * An alternative LCR (Lehmer Generator function) .
+   */
+  typedef linear_congruential<unsigned long, 48271, 0, 2147483647> minstd_rand;
+
+
+  /**
+   * A generalized feedback shift register discrete random number generator.
+   *
+   * This algorithm avoind multiplication and division and is designed to be
+   * friendly to a pipelined architecture.  If the parameters are chosen
+   * correctly, this generator will produce numbers with a very long period and
+   * fairly good apparent entropy, although still not cryptographically strong.
+   *
+   * The best way to use this generator is with the predefined mt19937 class.
+   *
+   * This algorithm was originally invented by Makoto Matsumoto and
+   * Takuji Nishimura.
+   *
+   * @var word_size   The number of bits in each element of the state vector.
+   * @var state_size  The degree of recursion.
+   * @var shift_size  The period parameter.
+   * @var mask_bits   The separation point bit index.
+   * @var parameter_a The last row of the twist matrix.
+   * @var output_u    The first right-shift tempering matrix parameter.
+   * @var output_s    The first left-shift tempering matrix parameter.
+   * @var output_b    The first left-shift tempering matrix mask.
+   * @var output_t    The second left-shift tempering matrix parameter.
+   * @var output_c    The second left-shift tempering matrix mask.
+   * @var output_l    The second right-shift tempering matrix parameter.
+   */
+  template<class _UIntType, int __w, int __n, int __m, int __r,
+	   _UIntType __a, int __u, int __s, _UIntType __b, int __t,
+	   _UIntType __c, int __l>
+    class mersenne_twister
+    {
+      __glibcxx_class_requires(_UIntType, _UnsignedIntegerConcept)
+
+    public:
+      // types
+      typedef _UIntType result_type;
+
+      // parameter values
+      static const int       word_size   = __w;
+      static const int       state_size  = __n;
+      static const int       shift_size  = __m;
+      static const int       mask_bits   = __r;
+      static const _UIntType parameter_a = __a;
+      static const int       output_u    = __u;
+      static const int       output_s    = __s;
+      static const _UIntType output_b    = __b;
+      static const int       output_t    = __t;
+      static const _UIntType output_c    = __c;
+      static const int       output_l    = __l;
+
+      // constructors and member function
+      mersenne_twister()
+      { seed(); }
+
+      explicit
+      mersenne_twister(unsigned long __value)
+      { seed(__value); }
+
+      template<class _Gen>
+        mersenne_twister(_Gen& __g)
+        { seed(__g); }
+
+      void
+      seed()
+      { seed(5489UL); }
+
+      void
+      seed(unsigned long __value);
+
+      template<class _Gen>
+        void
+        seed(_Gen& __g)
+        { seed(__g, typename is_fundamental<_Gen>::type()); }
+
+      result_type
+      min() const
+      { return 0; };
+
+      result_type
+      max() const
+      { return __detail::_Shift<_UIntType, __w>::__value - 1; }
+
+      result_type
+      operator()();
+
+      /**
+       * Compares two % mersenne_twister random number generator objects of
+       * the same type for equality.
+       *
+       * @param __lhs A % mersenne_twister random number generator object.
+       * @param __rhs Another % mersenne_twister random number generator
+       *              object.
+       *
+       * @returns true if the two objects are equal, false otherwise.
+       */
+      friend bool
+      operator==(const mersenne_twister& __lhs,
+		 const mersenne_twister& __rhs)
+      { return std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x); }
+
+      /**
+       * Compares two % mersenne_twister random number generator objects of
+       * the same type for inequality.
+       *
+       * @param __lhs A % mersenne_twister random number generator object.
+       * @param __rhs Another % mersenne_twister random number generator
+       *              object.
+       *
+       * @returns true if the two objects are not equal, false otherwise.
+       */
+      friend bool
+      operator!=(const mersenne_twister& __lhs,
+		 const mersenne_twister& __rhs)
+      { return !(__lhs == __rhs); }
+
+      /**
+       * Inserts the current state of a % mersenne_twister random number
+       * generator engine @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A % mersenne_twister random number generator engine.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<class _UIntType1, int __w1, int __n1, int __m1, int __r1,
+	       _UIntType1 __a1, int __u1, int __s1, _UIntType1 __b1, int __t1,
+	       _UIntType1 __c1, int __l1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const mersenne_twister<_UIntType1, __w1, __n1, __m1, __r1,
+		   __a1, __u1, __s1, __b1, __t1, __c1, __l1>& __x);
+
+      /**
+       * Extracts the current state of a % mersenne_twister random number
+       * generator engine @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A % mersenne_twister random number generator engine.
+       *
+       * @returns The input stream with the state of @p __x extracted or in
+       * an error state.
+       */
+      template<class _UIntType1, int __w1, int __n1, int __m1, int __r1,
+	       _UIntType1 __a1, int __u1, int __s1, _UIntType1 __b1, int __t1,
+	       _UIntType1 __c1, int __l1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   mersenne_twister<_UIntType1, __w1, __n1, __m1, __r1,
+		   __a1, __u1, __s1, __b1, __t1, __c1, __l1>& __x);
+
+    private:
+      template<class _Gen>
+        void
+        seed(_Gen& __g, true_type)
+        { return seed(static_cast<unsigned long>(__g)); }
+
+      template<class _Gen>
+        void
+        seed(_Gen& __g, false_type);
+
+      _UIntType _M_x[state_size];
+      int       _M_p;
+    };
+
+  /**
+   * The classic Mersenne Twister.
+   *
+   * Reference:
+   * M. Matsumoto and T. Nishimura, "Mersenne Twister: A 623-Dimensionally
+   * Equidistributed Uniform Pseudo-Random Number Generator", ACM Transactions
+   * on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30.
+   */
+  typedef mersenne_twister<
+    unsigned long, 32, 624, 397, 31,
+    0x9908b0dful, 11, 7,
+    0x9d2c5680ul, 15,
+    0xefc60000ul, 18
+    > mt19937;
+
+
+  /**
+   * @brief The Marsaglia-Zaman generator.
+   * 
+   * This is a model of a Generalized Fibonacci discrete random number
+   * generator, sometimes referred to as the SWC generator.
+   *
+   * A discrete random number generator that produces pseudorandom
+   * numbers using @f$x_{i}\leftarrow(x_{i - s} - x_{i - r} -
+   * carry_{i-1}) \bmod m @f$.
+   *
+   * The size of the state is @f$ r @f$
+   * and the maximum period of the generator is @f$ m^r - m^s -1 @f$.
+   *
+   * N1688[4.13] says "the template parameter _IntType shall denote an integral
+   * type large enough to store values up to m."
+   *
+   * @if maint
+   * @var _M_x     The state of the generator.  This is a ring buffer.
+   * @var _M_carry The carry.
+   * @var _M_p     Current index of x(i - r).
+   * @endif
+   */
+  template<typename _IntType, _IntType __m, int __s, int __r>
+    class subtract_with_carry
+    {
+      __glibcxx_class_requires(_IntType, _IntegerConcept)
+
+    public:
+      /** The type of the generated random value. */
+      typedef _IntType result_type;
+      
+      // parameter values
+      static const _IntType modulus   = __m;
+      static const int      long_lag  = __r;
+      static const int      short_lag = __s;
+
+      /**
+       * Constructs a default-initialized % subtract_with_carry random number
+       * generator.
+       */
+      subtract_with_carry()
+      { this->seed(); }
+
+      /**
+       * Constructs an explicitly seeded % subtract_with_carry random number
+       * generator.
+       */
+      explicit
+      subtract_with_carry(unsigned long __value)
+      { this->seed(__value); }
+
+      /**
+       * Constructs a %subtract_with_carry random number generator engine
+       * seeded from the generator function @p __g.
+       *
+       * @param __g The seed generator function.
+       */
+      template<class _Gen>
+        subtract_with_carry(_Gen& __g)
+        { this->seed(__g); }
+
+      /**
+       * Seeds the initial state @f$ x_0 @f$ of the random number generator.
+       *
+       * N1688[4.19] modifies this as follows.  If @p __value == 0,
+       * sets value to 19780503.  In any case, with a linear
+       * congruential generator lcg(i) having parameters @f$ m_{lcg} =
+       * 2147483563, a_{lcg} = 40014, c_{lcg} = 0, and lcg(0) = value
+       * @f$, sets @f$ x_{-r} \dots x_{-1} @f$ to @f$ lcg(1) \bmod m
+       * \dots lcg(r) \bmod m @f$ respectively.  If @f$ x_{-1} = 0 @f$
+       * set carry to 1, otherwise sets carry to 0.
+       */
+      void
+      seed(unsigned long __value = 19780503);
+
+      /**
+       * Seeds the initial state @f$ x_0 @f$ of the % subtract_with_carry
+       * random number generator.
+       */
+      template<class _Gen>
+        void
+        seed(_Gen& __g)
+        { seed(__g, typename is_fundamental<_Gen>::type()); }
+
+      /**
+       * Gets the inclusive minimum value of the range of random integers
+       * returned by this generator.
+       */
+      result_type
+      min() const
+      { return 0; }
+
+      /**
+       * Gets the inclusive maximum value of the range of random integers
+       * returned by this generator.
+       */
+      result_type
+      max() const
+      { return this->modulus - 1; }
+
+      /**
+       * Gets the next random number in the sequence.
+       */
+      result_type
+      operator()();
+
+      /**
+       * Compares two % subtract_with_carry random number generator objects of
+       * the same type for equality.
+       *
+       * @param __lhs A % subtract_with_carry random number generator object.
+       * @param __rhs Another % subtract_with_carry random number generator
+       *              object.
+       *
+       * @returns true if the two objects are equal, false otherwise.
+       */
+      friend bool
+      operator==(const subtract_with_carry& __lhs,
+		 const subtract_with_carry& __rhs)
+      { return std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x); }
+
+      /**
+       * Compares two % subtract_with_carry random number generator objects of
+       * the same type for inequality.
+       *
+       * @param __lhs A % subtract_with_carry random number generator object.
+       * @param __rhs Another % subtract_with_carry random number generator
+       *              object.
+       *
+       * @returns true if the two objects are not equal, false otherwise.
+       */
+      friend bool
+      operator!=(const subtract_with_carry& __lhs,
+		 const subtract_with_carry& __rhs)
+      { return !(__lhs == __rhs); }
+
+      /**
+       * Inserts the current state of a % subtract_with_carry random number
+       * generator engine @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A % subtract_with_carry random number generator engine.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _IntType1, _IntType1 __m1, int __s1, int __r1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const subtract_with_carry<_IntType1, __m1, __s1,
+		   __r1>& __x);
+
+      /**
+       * Extracts the current state of a % subtract_with_carry random number
+       * generator engine @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A % subtract_with_carry random number generator engine.
+       *
+       * @returns The input stream with the state of @p __x extracted or in
+       * an error state.
+       */
+      template<typename _IntType1, _IntType1 __m1, int __s1, int __r1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   subtract_with_carry<_IntType1, __m1, __s1, __r1>& __x);
+
+    private:
+      template<class _Gen>
+        void
+        seed(_Gen& __g, true_type)
+        { return seed(static_cast<unsigned long>(__g)); }
+
+      template<class _Gen>
+        void
+        seed(_Gen& __g, false_type);
+
+      typedef typename __gnu_cxx::__add_unsigned<_IntType>::__type _UIntType;
+
+      _UIntType  _M_x[long_lag];
+      _UIntType  _M_carry;
+      int        _M_p;
+    };
+
+
+  /**
+   * @brief The Marsaglia-Zaman generator (floats version).
+   *
+   * @if maint
+   * @var _M_x     The state of the generator.  This is a ring buffer.
+   * @var _M_carry The carry.
+   * @var _M_p     Current index of x(i - r).
+   * @var _M_npows Precomputed negative powers of 2.   
+   * @endif
+   */
+  template<typename _RealType, int __w, int __s, int __r>
+    class subtract_with_carry_01
+    {
+    public:
+      /** The type of the generated random value. */
+      typedef _RealType result_type;
+      
+      // parameter values
+      static const int      word_size = __w;
+      static const int      long_lag  = __r;
+      static const int      short_lag = __s;
+
+      /**
+       * Constructs a default-initialized % subtract_with_carry_01 random
+       * number generator.
+       */
+      subtract_with_carry_01()
+      {
+	this->seed();
+	_M_initialize_npows();
+      }
+
+      /**
+       * Constructs an explicitly seeded % subtract_with_carry_01 random number
+       * generator.
+       */
+      explicit
+      subtract_with_carry_01(unsigned long __value)
+      {
+	this->seed(__value);
+	_M_initialize_npows();
+      }
+
+      /**
+       * Constructs a % subtract_with_carry_01 random number generator engine
+       * seeded from the generator function @p __g.
+       *
+       * @param __g The seed generator function.
+       */
+      template<class _Gen>
+        subtract_with_carry_01(_Gen& __g)
+        {
+	  this->seed(__g);
+	  _M_initialize_npows();	  
+	}
+
+      /**
+       * Seeds the initial state @f$ x_0 @f$ of the random number generator.
+       */
+      void
+      seed(unsigned long __value = 19780503);
+
+      /**
+       * Seeds the initial state @f$ x_0 @f$ of the % subtract_with_carry_01
+       * random number generator.
+       */
+      template<class _Gen>
+        void
+        seed(_Gen& __g)
+        { seed(__g, typename is_fundamental<_Gen>::type()); }
+
+      /**
+       * Gets the minimum value of the range of random floats
+       * returned by this generator.
+       */
+      result_type
+      min() const
+      { return 0.0; }
+
+      /**
+       * Gets the maximum value of the range of random floats
+       * returned by this generator.
+       */
+      result_type
+      max() const
+      { return 1.0; }
+
+      /**
+       * Gets the next random number in the sequence.
+       */
+      result_type
+      operator()();
+
+      /**
+       * Compares two % subtract_with_carry_01 random number generator objects
+       * of the same type for equality.
+       *
+       * @param __lhs A % subtract_with_carry_01 random number
+       *              generator object.
+       * @param __rhs Another % subtract_with_carry_01 random number generator
+       *              object.
+       *
+       * @returns true if the two objects are equal, false otherwise.
+       */
+      friend bool
+      operator==(const subtract_with_carry_01& __lhs,
+		 const subtract_with_carry_01& __rhs)
+      {
+	for (int __i = 0; __i < long_lag; ++__i)
+	  if (!std::equal(__lhs._M_x[__i], __lhs._M_x[__i] + __n,
+			  __rhs._M_x[__i]))
+	    return false;
+	return true;
+      }
+
+      /**
+       * Compares two % subtract_with_carry_01 random number generator objects
+       * of the same type for inequality.
+       *
+       * @param __lhs A % subtract_with_carry_01 random number
+       *              generator object.
+       *
+       * @param __rhs Another % subtract_with_carry_01 random number generator
+       *              object.
+       *
+       * @returns true if the two objects are not equal, false otherwise.
+       */
+      friend bool
+      operator!=(const subtract_with_carry_01& __lhs,
+		 const subtract_with_carry_01& __rhs)
+      { return !(__lhs == __rhs); }
+
+      /**
+       * Inserts the current state of a % subtract_with_carry_01 random number
+       * generator engine @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A % subtract_with_carry_01 random number generator engine.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, int __w1, int __s1, int __r1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const subtract_with_carry_01<_RealType1, __w1, __s1,
+		   __r1>& __x);
+
+      /**
+       * Extracts the current state of a % subtract_with_carry_01 random number
+       * generator engine @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A % subtract_with_carry_01 random number generator engine.
+       *
+       * @returns The input stream with the state of @p __x extracted or in
+       * an error state.
+       */
+      template<typename _RealType1, int __w1, int __s1, int __r1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   subtract_with_carry_01<_RealType1, __w1, __s1, __r1>& __x);
+
+    private:
+      template<class _Gen>
+        void
+        seed(_Gen& __g, true_type)
+        { return seed(static_cast<unsigned long>(__g)); }
+
+      template<class _Gen>
+        void
+        seed(_Gen& __g, false_type);
+
+      void
+      _M_initialize_npows();
+
+      static const int __n = (__w + 31) / 32;
+
+      typedef __detail::_UInt32Type _UInt32Type;
+      _UInt32Type  _M_x[long_lag][__n];
+      _RealType    _M_npows[__n];
+      _UInt32Type  _M_carry;
+      int          _M_p;
+    };
+
+  typedef subtract_with_carry_01<float, 24, 10, 24>   ranlux_base_01;
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 508. Bad parameters for ranlux64_base_01.
+  typedef subtract_with_carry_01<double, 48, 5, 12> ranlux64_base_01;  
+
+
+  /**
+   * Produces random numbers from some base engine by discarding blocks of
+   * data.
+   *
+   * 0 <= @p __r <= @p __p
+   */
+  template<class _UniformRandomNumberGenerator, int __p, int __r>
+    class discard_block
+    {
+      // __glibcxx_class_requires(typename base_type::result_type,
+      //                          ArithmeticTypeConcept)
+
+    public:
+      /** The type of the underlying generator engine. */
+      typedef _UniformRandomNumberGenerator   base_type;
+      /** The type of the generated random value. */
+      typedef typename base_type::result_type result_type;
+
+      // parameter values
+      static const int block_size = __p;
+      static const int used_block = __r;
+
+      /**
+       * Constructs a default %discard_block engine.
+       *
+       * The underlying engine is default constructed as well.
+       */
+      discard_block()
+      : _M_n(0) { }
+
+      /**
+       * Copy constructs a %discard_block engine.
+       *
+       * Copies an existing base class random number geenerator.
+       * @param rng An existing (base class) engine object.
+       */
+      explicit
+      discard_block(const base_type& __rng)
+      : _M_b(__rng), _M_n(0) { }
+
+      /**
+       * Seed constructs a %discard_block engine.
+       *
+       * Constructs the underlying generator engine seeded with @p __s.
+       * @param __s A seed value for the base class engine.
+       */
+      explicit
+      discard_block(unsigned long __s)
+      : _M_b(__s), _M_n(0) { }
+
+      /**
+       * Generator construct a %discard_block engine.
+       *
+       * @param __g A seed generator function.
+       */
+      template<class _Gen>
+        discard_block(_Gen& __g)
+	: _M_b(__g), _M_n(0) { }
+
+      /**
+       * Reseeds the %discard_block object with the default seed for the
+       * underlying base class generator engine.
+       */
+      void seed()
+      {
+	_M_b.seed();
+	_M_n = 0;
+      }
+
+      /**
+       * Reseeds the %discard_block object with the given seed generator
+       * function.
+       * @param __g A seed generator function.
+       */
+      template<class _Gen>
+        void seed(_Gen& __g)
+        {
+	  _M_b.seed(__g);
+	  _M_n = 0;
+	}
+
+      /**
+       * Gets a const reference to the underlying generator engine object.
+       */
+      const base_type&
+      base() const
+      { return _M_b; }
+
+      /**
+       * Gets the minimum value in the generated random number range.
+       */
+      result_type
+      min() const
+      { return _M_b.min(); }
+
+      /**
+       * Gets the maximum value in the generated random number range.
+       */
+      result_type
+      max() const
+      { return _M_b.max(); }
+
+      /**
+       * Gets the next value in the generated random number sequence.
+       */
+      result_type
+      operator()();
+
+      /**
+       * Compares two %discard_block random number generator objects of
+       * the same type for equality.
+       *
+       * @param __lhs A %discard_block random number generator object.
+       * @param __rhs Another %discard_block random number generator
+       *              object.
+       *
+       * @returns true if the two objects are equal, false otherwise.
+       */
+      friend bool
+      operator==(const discard_block& __lhs, const discard_block& __rhs)
+      { return (__lhs._M_b == __rhs._M_b) && (__lhs._M_n == __rhs._M_n); }
+
+      /**
+       * Compares two %discard_block random number generator objects of
+       * the same type for inequality.
+       *
+       * @param __lhs A %discard_block random number generator object.
+       * @param __rhs Another %discard_block random number generator
+       *              object.
+       *
+       * @returns true if the two objects are not equal, false otherwise.
+       */
+      friend bool
+      operator!=(const discard_block& __lhs, const discard_block& __rhs)
+      { return !(__lhs == __rhs); }
+
+      /**
+       * Inserts the current state of a %discard_block random number
+       * generator engine @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %discard_block random number generator engine.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<class _UniformRandomNumberGenerator1, int __p1, int __r1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const discard_block<_UniformRandomNumberGenerator1,
+		   __p1, __r1>& __x);
+
+      /**
+       * Extracts the current state of a % subtract_with_carry random number
+       * generator engine @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %discard_block random number generator engine.
+       *
+       * @returns The input stream with the state of @p __x extracted or in
+       * an error state.
+       */
+      template<class _UniformRandomNumberGenerator1, int __p1, int __r1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   discard_block<_UniformRandomNumberGenerator1,
+		   __p1, __r1>& __x);
+
+    private:
+      base_type _M_b;
+      int       _M_n;
+    };
+
+
+  /**
+   * James's luxury-level-3 integer adaptation of Luescher's generator.
+   */
+  typedef discard_block<
+    subtract_with_carry<unsigned long, (1UL << 24), 10, 24>,
+      223,
+      24
+      > ranlux3;
+
+  /**
+   * James's luxury-level-4 integer adaptation of Luescher's generator.
+   */
+  typedef discard_block<
+    subtract_with_carry<unsigned long, (1UL << 24), 10, 24>,
+      389,
+      24
+      > ranlux4;
+
+  typedef discard_block<
+    subtract_with_carry_01<float, 24, 10, 24>,
+      223,
+      24
+      > ranlux3_01;
+
+  typedef discard_block<
+    subtract_with_carry_01<float, 24, 10, 24>,
+      389,
+      24
+      > ranlux4_01;
+
+
+  /**
+   * A random number generator adaptor class that combines two random number
+   * generator engines into a single output sequence.
+   */
+  template<class _UniformRandomNumberGenerator1, int __s1,
+	   class _UniformRandomNumberGenerator2, int __s2>
+    class xor_combine
+    {
+      // __glibcxx_class_requires(typename _UniformRandomNumberGenerator1::
+      //                          result_type, ArithmeticTypeConcept)
+      // __glibcxx_class_requires(typename _UniformRandomNumberGenerator2::
+      //                          result_type, ArithmeticTypeConcept)
+
+    public:
+      /** The type of the the first underlying generator engine. */
+      typedef _UniformRandomNumberGenerator1   base1_type;
+      /** The type of the the second underlying generator engine. */
+      typedef _UniformRandomNumberGenerator2   base2_type;
+
+    private:
+      typedef typename base1_type::result_type _Result_type1;
+      typedef typename base2_type::result_type _Result_type2;
+
+    public:
+      /** The type of the generated random value. */
+      typedef typename __gnu_cxx::__conditional_type<(sizeof(_Result_type1)
+						      > sizeof(_Result_type2)),
+	_Result_type1, _Result_type2>::__type result_type;
+
+      // parameter values
+      static const int shift1 = __s1;
+      static const int shift2 = __s2;
+
+      // constructors and member function
+      xor_combine()
+      : _M_b1(), _M_b2()	
+      { _M_initialize_max(); }
+
+      xor_combine(const base1_type& __rng1, const base2_type& __rng2)
+      : _M_b1(__rng1), _M_b2(__rng2)
+      { _M_initialize_max(); }
+
+      xor_combine(unsigned long __s)
+      : _M_b1(__s), _M_b2(__s + 1)
+      { _M_initialize_max(); }
+
+      template<class _Gen>
+        xor_combine(_Gen& __g)
+	: _M_b1(__g), _M_b2(__g)
+        { _M_initialize_max(); }
+
+      void
+      seed()
+      {
+	_M_b1.seed();
+	_M_b2.seed();
+      }
+
+      template<class _Gen>
+        void
+        seed(_Gen& __g)
+        {
+	  _M_b1.seed(__g);
+	  _M_b2.seed(__g);
+	}
+
+      const base1_type&
+      base1() const
+      { return _M_b1; }
+
+      const base2_type&
+      base2() const
+      { return _M_b2; }
+
+      result_type
+      min() const
+      { return 0; }
+
+      result_type
+      max() const
+      { return _M_max; }
+
+      /**
+       * Gets the next random number in the sequence.
+       */
+      // NB: Not exactly the TR1 formula, per N2079 instead.
+      result_type
+      operator()()
+      {
+	return ((result_type(_M_b1() - _M_b1.min()) << shift1)
+		^ (result_type(_M_b2() - _M_b2.min()) << shift2));
+      }
+
+      /**
+       * Compares two %xor_combine random number generator objects of
+       * the same type for equality.
+       *
+       * @param __lhs A %xor_combine random number generator object.
+       * @param __rhs Another %xor_combine random number generator
+       *              object.
+       *
+       * @returns true if the two objects are equal, false otherwise.
+       */
+      friend bool
+      operator==(const xor_combine& __lhs, const xor_combine& __rhs)
+      {
+	return (__lhs.base1() == __rhs.base1())
+	        && (__lhs.base2() == __rhs.base2());
+      }
+
+      /**
+       * Compares two %xor_combine random number generator objects of
+       * the same type for inequality.
+       *
+       * @param __lhs A %xor_combine random number generator object.
+       * @param __rhs Another %xor_combine random number generator
+       *              object.
+       *
+       * @returns true if the two objects are not equal, false otherwise.
+       */
+      friend bool
+      operator!=(const xor_combine& __lhs, const xor_combine& __rhs)
+      { return !(__lhs == __rhs); }
+
+      /**
+       * Inserts the current state of a %xor_combine random number
+       * generator engine @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %xor_combine random number generator engine.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<class _UniformRandomNumberGenerator11, int __s11,
+	       class _UniformRandomNumberGenerator21, int __s21,
+	       typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const xor_combine<_UniformRandomNumberGenerator11, __s11,
+		   _UniformRandomNumberGenerator21, __s21>& __x);
+
+      /**
+       * Extracts the current state of a %xor_combine random number
+       * generator engine @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %xor_combine random number generator engine.
+       *
+       * @returns The input stream with the state of @p __x extracted or in
+       * an error state.
+       */
+      template<class _UniformRandomNumberGenerator11, int __s11,
+	       class _UniformRandomNumberGenerator21, int __s21,
+	       typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   xor_combine<_UniformRandomNumberGenerator11, __s11,
+		   _UniformRandomNumberGenerator21, __s21>& __x);
+
+    private:
+      void
+      _M_initialize_max();
+
+      result_type
+      _M_initialize_max_aux(result_type, result_type, int);
+
+      base1_type  _M_b1;
+      base2_type  _M_b2;
+      result_type _M_max;
+    };
+
+
+  /**
+   * A standard interface to a platform-specific non-deterministic
+   * random number generator (if any are available).
+   */
+  class random_device
+  {
+  public:
+    // types
+    typedef unsigned int result_type;
+
+    // constructors, destructors and member functions
+
+#ifdef _GLIBCXX_USE_RANDOM_TR1
+
+    explicit
+    random_device(const std::string& __token = "/dev/urandom")
+    {
+      if ((__token != "/dev/urandom" && __token != "/dev/random")
+	  || !(_M_file = std::fopen(__token.c_str(), "rb")))
+	std::__throw_runtime_error(__N("random_device::"
+				       "random_device(const std::string&)"));
+    }
+
+    ~random_device()
+    { std::fclose(_M_file); }
+
+#else
+
+    explicit
+    random_device(const std::string& __token = "mt19937")
+    : _M_mt(_M_strtoul(__token)) { }
+
+  private:
+    static unsigned long
+    _M_strtoul(const std::string& __str)
+    {
+      unsigned long __ret = 5489UL;
+      if (__str != "mt19937")
+	{
+	  const char* __nptr = __str.c_str();
+	  char* __endptr;
+	  __ret = std::strtoul(__nptr, &__endptr, 0);
+	  if (*__nptr == '\0' || *__endptr != '\0')
+	    std::__throw_runtime_error(__N("random_device::_M_strtoul"
+					   "(const std::string&)"));
+	}
+      return __ret;
+    }
+
+  public:
+
+#endif
+
+    result_type
+    min() const
+    { return std::numeric_limits<result_type>::min(); }
+
+    result_type
+    max() const
+    { return std::numeric_limits<result_type>::max(); }
+
+    double
+    entropy() const
+    { return 0.0; }
+
+    result_type
+    operator()()
+    {
+#ifdef _GLIBCXX_USE_RANDOM_TR1
+      result_type __ret;
+      std::fread(reinterpret_cast<void*>(&__ret), sizeof(result_type),
+		 1, _M_file);
+      return __ret;
+#else
+      return _M_mt();
+#endif
+    }
+
+  private:
+    random_device(const random_device&);
+    void operator=(const random_device&);
+
+#ifdef _GLIBCXX_USE_RANDOM_TR1
+    FILE*        _M_file;
+#else
+    mt19937      _M_mt;
+#endif
+  };
+
+  /* @} */ // group tr1_random_generators
+
+  /**
+   * @addtogroup tr1_random_distributions Random Number Distributions
+   * @ingroup tr1_random
+   * @{
+   */
+
+  /**
+   * @addtogroup tr1_random_distributions_discrete Discrete Distributions
+   * @ingroup tr1_random_distributions
+   * @{
+   */
+
+  /**
+   * @brief Uniform discrete distribution for random numbers.
+   * A discrete random distribution on the range @f$[min, max]@f$ with equal
+   * probability throughout the range.
+   */
+  template<typename _IntType = int>
+    class uniform_int
+    {
+      __glibcxx_class_requires(_IntType, _IntegerConcept)
+ 
+    public:
+      /** The type of the parameters of the distribution. */
+      typedef _IntType input_type;
+      /** The type of the range of the distribution. */
+      typedef _IntType result_type;
+
+    public:
+      /**
+       * Constructs a uniform distribution object.
+       */
+      explicit
+      uniform_int(_IntType __min = 0, _IntType __max = 9)
+      : _M_min(__min), _M_max(__max)
+      {
+	_GLIBCXX_DEBUG_ASSERT(_M_min <= _M_max);
+      }
+
+      /**
+       * Gets the inclusive lower bound of the distribution range.
+       */
+      result_type
+      min() const
+      { return _M_min; }
+
+      /**
+       * Gets the inclusive upper bound of the distribution range.
+       */
+      result_type
+      max() const
+      { return _M_max; }
+
+      /**
+       * Resets the distribution state.
+       *
+       * Does nothing for the uniform integer distribution.
+       */
+      void
+      reset() { }
+
+      /**
+       * Gets a uniformly distributed random number in the range
+       * @f$(min, max)@f$.
+       */
+      template<typename _UniformRandomNumberGenerator>
+        result_type
+        operator()(_UniformRandomNumberGenerator& __urng)
+        {
+	  typedef typename _UniformRandomNumberGenerator::result_type
+	    _UResult_type;
+	  return _M_call(__urng, _M_min, _M_max,
+			 typename is_integral<_UResult_type>::type());
+	}
+
+      /**
+       * Gets a uniform random number in the range @f$[0, n)@f$.
+       *
+       * This function is aimed at use with std::random_shuffle.
+       */
+      template<typename _UniformRandomNumberGenerator>
+        result_type
+        operator()(_UniformRandomNumberGenerator& __urng, result_type __n)
+        {
+	  typedef typename _UniformRandomNumberGenerator::result_type
+	    _UResult_type;
+	  return _M_call(__urng, 0, __n - 1,
+			 typename is_integral<_UResult_type>::type());
+	}
+
+      /**
+       * Inserts a %uniform_int random number distribution @p __x into the
+       * output stream @p os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %uniform_int random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _IntType1, typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const uniform_int<_IntType1>& __x);
+
+      /**
+       * Extracts a %unform_int random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %uniform_int random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _IntType1, typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   uniform_int<_IntType1>& __x);
+
+    private:
+      template<typename _UniformRandomNumberGenerator>
+        result_type
+        _M_call(_UniformRandomNumberGenerator& __urng,
+		result_type __min, result_type __max, true_type)
+        { return result_type(__urng() % (__max - __min + 1)) + __min; }
+
+      template<typename _UniformRandomNumberGenerator>
+        result_type
+        _M_call(_UniformRandomNumberGenerator& __urng,
+		result_type __min, result_type __max, false_type)
+        {
+	  return result_type((__urng() - __urng.min())
+			     / (__urng.max() - __urng.min())
+			     * (__max - __min + 1)) + __min;
+	}
+
+      _IntType _M_min;
+      _IntType _M_max;
+    };
+
+
+  /**
+   * @brief A Bernoulli random number distribution.
+   *
+   * Generates a sequence of true and false values with likelihood @f$ p @f$
+   * that true will come up and @f$ (1 - p) @f$ that false will appear.
+   */
+  class bernoulli_distribution
+  {
+  public:
+    typedef int  input_type;
+    typedef bool result_type;
+
+  public:
+    /**
+     * Constructs a Bernoulli distribution with likelihood @p p.
+     *
+     * @param __p  [IN]  The likelihood of a true result being returned.  Must
+     * be in the interval @f$ [0, 1] @f$.
+     */
+    explicit
+    bernoulli_distribution(double __p = 0.5)
+    : _M_p(__p)
+    { 
+      _GLIBCXX_DEBUG_ASSERT((_M_p >= 0.0) && (_M_p <= 1.0));
+    }
+
+    /**
+     * Gets the @p p parameter of the distribution.
+     */
+    double
+    p() const
+    { return _M_p; }
+
+    /**
+     * Resets the distribution state.
+     *
+     * Does nothing for a bernoulli distribution.
+     */
+    void
+    reset() { }
+
+    /**
+     * Gets the next value in the Bernoullian sequence.
+     */
+    template<class _UniformRandomNumberGenerator>
+      result_type
+      operator()(_UniformRandomNumberGenerator& __urng)
+      {
+	if ((__urng() - __urng.min()) < _M_p * (__urng.max() - __urng.min()))
+	  return true;
+	return false;
+      }
+
+    /**
+     * Inserts a %bernoulli_distribution random number distribution
+     * @p __x into the output stream @p __os.
+     *
+     * @param __os An output stream.
+     * @param __x  A %bernoulli_distribution random number distribution.
+     *
+     * @returns The output stream with the state of @p __x inserted or in
+     * an error state.
+     */
+    template<typename _CharT, typename _Traits>
+      friend std::basic_ostream<_CharT, _Traits>&
+      operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		 const bernoulli_distribution& __x);
+
+    /**
+     * Extracts a %bernoulli_distribution random number distribution
+     * @p __x from the input stream @p __is.
+     *
+     * @param __is An input stream.
+     * @param __x  A %bernoulli_distribution random number generator engine.
+     *
+     * @returns The input stream with @p __x extracted or in an error state.
+     */
+    template<typename _CharT, typename _Traits>
+      friend std::basic_istream<_CharT, _Traits>&
+      operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		 bernoulli_distribution& __x)
+      { return __is >> __x._M_p; }
+
+  private:
+    double _M_p;
+  };
+
+
+  /**
+   * @brief A discrete geometric random number distribution.
+   *
+   * The formula for the geometric probability mass function is 
+   * @f$ p(i) = (1 - p)p^{i-1} @f$ where @f$ p @f$ is the parameter of the
+   * distribution.
+   */
+  template<typename _IntType = int, typename _RealType = double>
+    class geometric_distribution
+    {
+    public:
+      // types
+      typedef _RealType input_type;
+      typedef _IntType  result_type;
+
+      // constructors and member function
+      explicit
+      geometric_distribution(const _RealType& __p = _RealType(0.5))
+      : _M_p(__p)
+      {
+	_GLIBCXX_DEBUG_ASSERT((_M_p > 0.0) && (_M_p < 1.0));
+	_M_initialize();
+      }
+
+      /**
+       * Gets the distribution parameter @p p.
+       */
+      _RealType
+      p() const
+      { return _M_p; }
+
+      void
+      reset() { }
+
+      template<class _UniformRandomNumberGenerator>
+        result_type
+        operator()(_UniformRandomNumberGenerator& __urng);
+
+      /**
+       * Inserts a %geometric_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %geometric_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _IntType1, typename _RealType1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const geometric_distribution<_IntType1, _RealType1>& __x);
+
+      /**
+       * Extracts a %geometric_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %geometric_distribution random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   geometric_distribution& __x)
+        {
+	  __is >> __x._M_p;
+	  __x._M_initialize();
+	  return __is;
+	}
+
+    private:
+      void
+      _M_initialize()
+      { _M_log_p = std::log(_M_p); }
+
+      _RealType _M_p;
+      _RealType _M_log_p;
+    };
+
+
+  template<typename _RealType>
+    class normal_distribution;
+
+  /**
+   * @brief A discrete Poisson random number distribution.
+   *
+   * The formula for the poisson probability mass function is 
+   * @f$ p(i) = \frac{mean^i}{i!} e^{-mean} @f$ where @f$ mean @f$ is the
+   * parameter of the distribution.
+   */
+  template<typename _IntType = int, typename _RealType = double>
+    class poisson_distribution
+    {
+    public:
+      // types
+      typedef _RealType input_type;
+      typedef _IntType  result_type;
+
+      // constructors and member function
+      explicit
+      poisson_distribution(const _RealType& __mean = _RealType(1))
+      : _M_mean(__mean), _M_nd()
+      {
+	_GLIBCXX_DEBUG_ASSERT(_M_mean > 0.0);
+	_M_initialize();
+      }
+
+      /**
+       * Gets the distribution parameter @p mean.
+       */
+      _RealType
+      mean() const
+      { return _M_mean; }
+
+      void
+      reset()
+      { _M_nd.reset(); }
+
+      template<class _UniformRandomNumberGenerator>
+        result_type
+        operator()(_UniformRandomNumberGenerator& __urng);
+
+      /**
+       * Inserts a %poisson_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %poisson_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _IntType1, typename _RealType1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const poisson_distribution<_IntType1, _RealType1>& __x);
+
+      /**
+       * Extracts a %poisson_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %poisson_distribution random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _IntType1, typename _RealType1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   poisson_distribution<_IntType1, _RealType1>& __x);
+
+    private:
+      void
+      _M_initialize();
+
+      // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
+      normal_distribution<_RealType> _M_nd;
+
+      _RealType _M_mean;
+
+      // Hosts either log(mean) or the threshold of the simple method.
+      _RealType _M_lm_thr;
+#if _GLIBCXX_USE_C99_MATH_TR1
+      _RealType _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
+#endif
+    };
+
+
+  /**
+   * @brief A discrete binomial random number distribution.
+   *
+   * The formula for the binomial probability mass function is 
+   * @f$ p(i) = \binom{n}{i} p^i (1 - p)^{t - i} @f$ where @f$ t @f$
+   * and @f$ p @f$ are the parameters of the distribution.
+   */
+  template<typename _IntType = int, typename _RealType = double>
+    class binomial_distribution
+    {
+    public:
+      // types
+      typedef _RealType input_type;
+      typedef _IntType  result_type;
+
+      // constructors and member function
+      explicit
+      binomial_distribution(_IntType __t = 1,
+			    const _RealType& __p = _RealType(0.5))
+      : _M_t(__t), _M_p(__p), _M_nd()
+      {
+	_GLIBCXX_DEBUG_ASSERT((_M_t >= 0) && (_M_p >= 0.0) && (_M_p <= 1.0));
+	_M_initialize();
+      }
+
+      /**
+       * Gets the distribution @p t parameter.
+       */
+      _IntType
+      t() const
+      { return _M_t; }
+      
+      /**
+       * Gets the distribution @p p parameter.
+       */
+      _RealType
+      p() const
+      { return _M_p; }
+
+      void
+      reset()
+      { _M_nd.reset(); }
+
+      template<class _UniformRandomNumberGenerator>
+        result_type
+        operator()(_UniformRandomNumberGenerator& __urng);
+
+      /**
+       * Inserts a %binomial_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %binomial_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _IntType1, typename _RealType1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const binomial_distribution<_IntType1, _RealType1>& __x);
+
+      /**
+       * Extracts a %binomial_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %binomial_distribution random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _IntType1, typename _RealType1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   binomial_distribution<_IntType1, _RealType1>& __x);
+
+    private:
+      void
+      _M_initialize();
+
+      template<class _UniformRandomNumberGenerator>
+        result_type
+        _M_waiting(_UniformRandomNumberGenerator& __urng, _IntType __t);
+
+      // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
+      normal_distribution<_RealType> _M_nd;
+
+      _RealType _M_q;
+#if _GLIBCXX_USE_C99_MATH_TR1
+      _RealType _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
+	        _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
+#endif
+      _RealType _M_p;
+      _IntType  _M_t;
+
+      bool      _M_easy;
+    };
+
+  /* @} */ // group tr1_random_distributions_discrete
+
+  /**
+   * @addtogroup tr1_random_distributions_continuous Continuous Distributions
+   * @ingroup tr1_random_distributions
+   * @{
+   */
+
+  /**
+   * @brief Uniform continuous distribution for random numbers.
+   *
+   * A continuous random distribution on the range [min, max) with equal
+   * probability throughout the range.  The URNG should be real-valued and
+   * deliver number in the range [0, 1).
+   */
+  template<typename _RealType = double>
+    class uniform_real
+    {
+    public:
+      // types
+      typedef _RealType input_type;
+      typedef _RealType result_type;
+
+    public:
+      /**
+       * Constructs a uniform_real object.
+       *
+       * @param __min [IN]  The lower bound of the distribution.
+       * @param __max [IN]  The upper bound of the distribution.
+       */
+      explicit
+      uniform_real(_RealType __min = _RealType(0),
+		   _RealType __max = _RealType(1))
+      : _M_min(__min), _M_max(__max)
+      {
+	_GLIBCXX_DEBUG_ASSERT(_M_min <= _M_max);
+      }
+
+      result_type
+      min() const
+      { return _M_min; }
+
+      result_type
+      max() const
+      { return _M_max; }
+
+      void
+      reset() { }
+
+      template<class _UniformRandomNumberGenerator>
+        result_type
+        operator()(_UniformRandomNumberGenerator& __urng)
+        { return (__urng() * (_M_max - _M_min)) + _M_min; }
+
+      /**
+       * Inserts a %uniform_real random number distribution @p __x into the
+       * output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %uniform_real random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const uniform_real<_RealType1>& __x);
+
+      /**
+       * Extracts a %unform_real random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %uniform_real random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   uniform_real<_RealType1>& __x);
+
+    private:
+      _RealType _M_min;
+      _RealType _M_max;
+    };
+
+
+  /**
+   * @brief An exponential continuous distribution for random numbers.
+   *
+   * The formula for the exponential probability mass function is 
+   * @f$ p(x) = \lambda e^{-\lambda x} @f$.
+   *
+   * <table border=1 cellpadding=10 cellspacing=0>
+   * <caption align=top>Distribution Statistics</caption>
+   * <tr><td>Mean</td><td>@f$ \frac{1}{\lambda} @f$</td></tr>
+   * <tr><td>Median</td><td>@f$ \frac{\ln 2}{\lambda} @f$</td></tr>
+   * <tr><td>Mode</td><td>@f$ zero @f$</td></tr>
+   * <tr><td>Range</td><td>@f$[0, \infty]@f$</td></tr>
+   * <tr><td>Standard Deviation</td><td>@f$ \frac{1}{\lambda} @f$</td></tr>
+   * </table>
+   */
+  template<typename _RealType = double>
+    class exponential_distribution
+    {
+    public:
+      // types
+      typedef _RealType input_type;
+      typedef _RealType result_type;
+
+    public:
+      /**
+       * Constructs an exponential distribution with inverse scale parameter
+       * @f$ \lambda @f$.
+       */
+      explicit
+      exponential_distribution(const result_type& __lambda = result_type(1))
+      : _M_lambda(__lambda)
+      { 
+	_GLIBCXX_DEBUG_ASSERT(_M_lambda > 0);
+      }
+
+      /**
+       * Gets the inverse scale parameter of the distribution.
+       */
+      _RealType
+      lambda() const
+      { return _M_lambda; }
+
+      /**
+       * Resets the distribution.
+       *
+       * Has no effect on exponential distributions.
+       */
+      void
+      reset() { }
+
+      template<class _UniformRandomNumberGenerator>
+        result_type
+        operator()(_UniformRandomNumberGenerator& __urng)
+        { return -std::log(__urng()) / _M_lambda; }
+
+      /**
+       * Inserts a %exponential_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %exponential_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const exponential_distribution<_RealType1>& __x);
+
+      /**
+       * Extracts a %exponential_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x A %exponential_distribution random number
+       *            generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   exponential_distribution& __x)
+        { return __is >> __x._M_lambda; }
+
+    private:
+      result_type _M_lambda;
+    };
+
+
+  /**
+   * @brief A normal continuous distribution for random numbers.
+   *
+   * The formula for the normal probability mass function is 
+   * @f$ p(x) = \frac{1}{\sigma \sqrt{2 \pi}} 
+   *            e^{- \frac{{x - mean}^ {2}}{2 \sigma ^ {2}} } @f$.
+   */
+  template<typename _RealType = double>
+    class normal_distribution
+    {
+    public:
+      // types
+      typedef _RealType input_type;
+      typedef _RealType result_type;
+
+    public:
+      /**
+       * Constructs a normal distribution with parameters @f$ mean @f$ and
+       * @f$ \sigma @f$.
+       */
+      explicit
+      normal_distribution(const result_type& __mean = result_type(0),
+			  const result_type& __sigma = result_type(1))
+      : _M_mean(__mean), _M_sigma(__sigma), _M_saved_available(false)
+      { 
+	_GLIBCXX_DEBUG_ASSERT(_M_sigma > 0);
+      }
+
+      /**
+       * Gets the mean of the distribution.
+       */
+      _RealType
+      mean() const
+      { return _M_mean; }
+
+      /**
+       * Gets the @f$ \sigma @f$ of the distribution.
+       */
+      _RealType
+      sigma() const
+      { return _M_sigma; }
+
+      /**
+       * Resets the distribution.
+       */
+      void
+      reset()
+      { _M_saved_available = false; }
+
+      template<class _UniformRandomNumberGenerator>
+        result_type
+        operator()(_UniformRandomNumberGenerator& __urng);
+
+      /**
+       * Inserts a %normal_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %normal_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const normal_distribution<_RealType1>& __x);
+
+      /**
+       * Extracts a %normal_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %normal_distribution random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   normal_distribution<_RealType1>& __x);
+
+    private:
+      result_type _M_mean;
+      result_type _M_sigma;
+      result_type _M_saved;
+      bool        _M_saved_available;     
+    };
+
+
+  /**
+   * @brief A gamma continuous distribution for random numbers.
+   *
+   * The formula for the gamma probability mass function is 
+   * @f$ p(x) = \frac{1}{\Gamma(\alpha)} x^{\alpha - 1} e^{-x} @f$.
+   */
+  template<typename _RealType = double>
+    class gamma_distribution
+    {
+    public:
+      // types
+      typedef _RealType input_type;
+      typedef _RealType result_type;
+
+    public:
+      /**
+       * Constructs a gamma distribution with parameters @f$ \alpha @f$.
+       */
+      explicit
+      gamma_distribution(const result_type& __alpha_val = result_type(1))
+      : _M_alpha(__alpha_val)
+      { 
+	_GLIBCXX_DEBUG_ASSERT(_M_alpha > 0);
+	_M_initialize();
+      }
+
+      /**
+       * Gets the @f$ \alpha @f$ of the distribution.
+       */
+      _RealType
+      alpha() const
+      { return _M_alpha; }
+
+      /**
+       * Resets the distribution.
+       */
+      void
+      reset() { }
+
+      template<class _UniformRandomNumberGenerator>
+        result_type
+        operator()(_UniformRandomNumberGenerator& __urng);
+
+      /**
+       * Inserts a %gamma_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %gamma_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const gamma_distribution<_RealType1>& __x);
+
+      /**
+       * Extracts a %gamma_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %gamma_distribution random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   gamma_distribution& __x)
+        {
+	  __is >> __x._M_alpha;
+	  __x._M_initialize();
+	  return __is;
+	}
+
+    private:
+      void
+      _M_initialize();
+
+      result_type _M_alpha;
+
+      // Hosts either lambda of GB or d of modified Vaduva's.
+      result_type _M_l_d;
+    };
+
+  /* @} */ // group tr1_random_distributions_continuous
+  /* @} */ // group tr1_random_distributions
+  /* @} */ // group tr1_random
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
+
+#include <tr1_impl/random.tcc>
diff --git a/libstdc++-v3/include/tr1/random.tcc b/libstdc++-v3/include/tr1_impl/random.tcc
index c5ae933..e57d609 100644
--- a/libstdc++-v3/include/tr1/random.tcc
+++ b/libstdc++-v3/include/tr1_impl/random.tcc
@@ -1,6 +1,6 @@
 // random number generation (out of line) -*- C++ -*-
 
-// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -27,13 +27,14 @@
 // invalidate any other reasons why the executable file might be covered by
 // the GNU General Public License.
 
-/** @file tr1/random.tcc
- *  This is a TR1 C++ Library header. 
+/** @file tr1_impl/random.tcc
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
  */
 
 namespace std
 {
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+_GLIBCXX_BEGIN_NAMESPACE_TR1
 
   /*
    * (Further) implementation-space details.
@@ -322,7 +323,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
       if (__value == 0)
 	__value = 19780503;
 
-      std::_GLIBCXX_TR1::linear_congruential<unsigned long, 40014, 0, 2147483563>
+      std::_GLIBCXX_TR1 linear_congruential<unsigned long, 40014, 0, 2147483563>
 	__lcg(__value);
 
       for (int __i = 0; __i < long_lag; ++__i)
@@ -441,7 +442,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
     {
       for (int __j = 0; __j < __n; ++__j)
 #if _GLIBCXX_USE_C99_MATH_TR1
-	_M_npows[__j] = std::_GLIBCXX_TR1::ldexp(_RealType(1), -__w + __j * 32);
+	_M_npows[__j] = std::_GLIBCXX_TR1 ldexp(_RealType(1), -__w + __j * 32);
 #else
         _M_npows[__j] = std::pow(_RealType(2), -__w + __j * 32);
 #endif
@@ -457,7 +458,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 
       // _GLIBCXX_RESOLVE_LIB_DEFECTS
       // 512. Seeding subtract_with_carry_01 from a single unsigned long.
-      std::_GLIBCXX_TR1::linear_congruential<unsigned long, 40014, 0, 2147483563>
+      std::_GLIBCXX_TR1 linear_congruential<unsigned long, 40014, 0, 2147483563>
 	__lcg(__value);
 
       this->seed(__lcg);
@@ -869,14 +870,14 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 	{
 	  const _RealType __m = std::floor(_M_mean);
 	  _M_lm_thr = std::log(_M_mean);
-	  _M_lfm = std::_GLIBCXX_TR1::lgamma(__m + 1);
+	  _M_lfm = std::_GLIBCXX_TR1 lgamma(__m + 1);
 	  _M_sm = std::sqrt(__m);
 
 	  const _RealType __pi_4 = 0.7853981633974483096156608458198757L;
 	  const _RealType __dx = std::sqrt(2 * __m * std::log(32 * __m
 							      / __pi_4));
-	  _M_d = std::_GLIBCXX_TR1::round(std::max(_RealType(6),
-					  std::min(__m, __dx)));
+	  _M_d = std::_GLIBCXX_TR1 round(std::max(_RealType(6),
+						  std::min(__m, __dx)));
 	  const _RealType __cx = 2 * __m + _M_d;
 	  _M_scx = std::sqrt(__cx / 2);
 	  _M_1cx = 1 / __cx;
@@ -972,7 +973,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 		  }
 
 		__reject = (__w - __e - __x * _M_lm_thr
-			    > _M_lfm - std::_GLIBCXX_TR1::lgamma(__x + __m + 1));
+			    > _M_lfm - std::_GLIBCXX_TR1 lgamma(__x + __m + 1));
 
 		__reject |= __x + __m >= __thr;
 
@@ -1063,11 +1064,11 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 	  const _RealType __d1x =
 	    std::sqrt(__np * __1p * std::log(32 * __np
 					     / (81 * __pi_4 * __1p)));
-	  _M_d1 = std::_GLIBCXX_TR1::round(std::max(_RealType(1), __d1x));
+	  _M_d1 = std::_GLIBCXX_TR1 round(std::max(_RealType(1), __d1x));
 	  const _RealType __d2x =
 	    std::sqrt(__np * __1p * std::log(32 * _M_t * __1p
 					     / (__pi_4 * __pa)));
-	  _M_d2 = std::_GLIBCXX_TR1::round(std::max(_RealType(1), __d2x));
+	  _M_d2 = std::_GLIBCXX_TR1 round(std::max(_RealType(1), __d2x));
 	  
 	  // sqrt(pi / 2)
 	  const _RealType __spi_2 = 1.2533141373155002512078826424055226L;
@@ -1083,8 +1084,8 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 	  const _RealType __s2s = _M_s2 * _M_s2;
 	  _M_s = (_M_a123 + 2 * __s2s / _M_d2
 		  * std::exp(-_M_d2 * _M_d2 / (2 * __s2s)));
-	  _M_lf = (std::_GLIBCXX_TR1::lgamma(__np + 1)
-		   + std::_GLIBCXX_TR1::lgamma(_M_t - __np + 1));
+	  _M_lf = (std::_GLIBCXX_TR1 lgamma(__np + 1)
+		   + std::_GLIBCXX_TR1 lgamma(_M_t - __np + 1));
 	  _M_lp1p = std::log(__pa / __1p);
 
 	  _M_q = -std::log(1 - (__p12 - __pa) / __1p);
@@ -1212,8 +1213,8 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 		if (!__reject)
 		  {
 		    const _RealType __lfx =
-		      std::_GLIBCXX_TR1::lgamma(__np + __x + 1)
-		      + std::_GLIBCXX_TR1::lgamma(_M_t - (__np + __x) + 1);
+		      std::_GLIBCXX_TR1 lgamma(__np + __x + 1)
+		      + std::_GLIBCXX_TR1 lgamma(_M_t - (__np + __x) + 1);
 		    __reject = __v > _M_lf - __lfx + __x * _M_lp1p;
 		  }
 
@@ -1543,5 +1544,5 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
       return __os;
     }
 
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_TR1
 }
diff --git a/libstdc++-v3/include/tr1_impl/regex b/libstdc++-v3/include/tr1_impl/regex
new file mode 100644
index 0000000..de695dd
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/regex
@@ -0,0 +1,2414 @@
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/**
+ * @file tr1_impl/regex
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+/**
+ * @addtogroup tr1_regex Regular Expressions
+ * A facility for performing regular expression pattern matching.
+ * @{
+ */
+
+namespace regex_constants
+{
+  // [7.5.1] Bitmask Type syntax_option_type
+  enum __syntax_option
+    {
+      _S_icase,
+      _S_nosubs,
+      _S_optimize,
+      _S_collate,
+      _S_ECMAScript,
+      _S_basic,
+      _S_extended,
+      _S_awk,
+      _S_grep,
+      _S_egrep,
+      _S_syntax_last
+    };
+
+  /**
+   * @brief This is a bitmask type indicating how to interpret the regex.
+   *
+   * The @c syntax_option_type is implementation defined but it is valid to
+   * perform bitwise operations on these values and expect the right thing to
+   * happen.
+   *
+   * A valid value of type syntax_option_type shall have exactly one of the
+   * elements @c ECMAScript, @c basic, @c extended, @c awk, @c grep, @c egrep
+   * set.
+   */
+  typedef unsigned int syntax_option_type;
+
+  /// Specifies that the matching of regular expressions against a character
+  /// sequence shall be performed without regard to case.
+  static const syntax_option_type icase      = 1 << _S_icase;
+
+  /// Specifies that when a regular expression is matched against a character
+  /// container sequence, no sub-expression matches are to be stored in the
+  /// supplied match_results structure.
+  static const syntax_option_type nosubs     = 1 << _S_nosubs;
+
+  /// Specifies that the regular expression engine should pay more attention to
+  /// the speed with which regular expressions are matched, and less to the
+  /// speed with which regular expression objects are constructed. Otherwise
+  /// it has no detectable effect on the program output.
+  static const syntax_option_type optimize   = 1 << _S_optimize;
+
+  /// Specifies that character ranges of the form [a-b] should be locale
+  /// sensitive.
+  static const syntax_option_type collate    = 1 << _S_collate;
+
+  /// Specifies that the grammar recognized by the regular expression engine is
+  /// that used by ECMAScript in ECMA-262 [Ecma International, ECMAScript
+  /// Language Specification, Standard Ecma-262, third edition, 1999], as
+  /// modified in tr1 section [7.13].  This grammar is similar to that defined
+  /// in the PERL scripting language but extended with elements found in the
+  /// POSIX regular expression grammar.
+  static const syntax_option_type ECMAScript = 1 << _S_ECMAScript;
+
+  /// Specifies that the grammar recognized by the regular expression engine is
+  /// that used by POSIX basic regular expressions in IEEE Std 1003.1-2001,
+  /// Portable Operating System Interface (POSIX), Base Definitions and
+  /// Headers, Section 9, Regular Expressions [IEEE, Information Technology --
+  /// Portable Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
+  static const syntax_option_type basic      = 1 << _S_basic;
+
+  /// Specifies that the grammar recognized by the regular expression engine is
+  /// that used by POSIX extended regular expressions in IEEE Std 1003.1-2001,
+  /// Portable Operating System Interface (POSIX), Base Definitions and Headers,
+  /// Section 9, Regular Expressions.
+  static const syntax_option_type extended   = 1 << _S_extended;
+
+  /// Specifies that the grammar recognized by the regular expression engine is
+  /// that used by POSIX utility awk in IEEE Std 1003.1-2001.  This option is
+  /// identical to syntax_option_type extended, except that C-style escape
+  /// sequences are supported.  These sequences are, explicitly, '\\', '\a',
+  /// '\b', '\f', '\n', '\r', '\t' , '\v', '\"', '\\', and '\ddd' (where ddd is
+  /// one, two, or three octal digits).  
+  static const syntax_option_type awk        = 1 << _S_awk;
+
+  /// Specifies that the grammar recognized by the regular expression engine is
+  /// that used by POSIX utility grep in IEEE Std 1003.1-2001.  This option is
+  /// identical to syntax_option_type basic, except that newlines are treated
+  /// as whitespace.
+  static const syntax_option_type grep       = 1 << _S_grep;
+
+  /// Specifies that the grammar recognized by the regular expression engine is
+  /// that used by POSIX utility grep when given the -E option in
+  /// IEEE Std 1003.1-2001.  This option is identical to syntax_option_type 
+  /// extended, except that newlines are treated as whitespace.
+  static const syntax_option_type egrep      = 1 << _S_egrep;
+
+
+  // [7.5.2] Bitmask Type match_flag_type
+  enum __match_flag
+    {
+      _S_not_bol,
+      _S_not_eol,
+      _S_not_bow,
+      _S_not_eow,
+      _S_any,
+      _S_not_null,
+      _S_continuous,
+      _S_prev_avail,
+      _S_sed,
+      _S_no_copy,
+      _S_first_only,
+      _S_match_flag_last
+    };
+
+  /**
+   * @brief This is a bitmask type indicating regex matching rules.
+   *
+   * Matching a regular expression against a sequence of characters [first,
+   * last) proceeds according to the rules of the grammar specified for the
+   * regular expression object, modified according to the effects listed
+   * below for any bitmask elements set.
+   *
+   * The @c match_flag_type is implementation defined but it is valid to
+   * perform bitwise operations on these values and expect the right thing to
+   * happen.
+   */
+  typedef std::bitset<_S_match_flag_last> match_flag_type;
+
+  static const match_flag_type match_default     = 0;
+
+  /// The first character in the sequence [first, last) is treated as though it
+  /// is not at the beginning of a line, so the character "^" in the regular
+  /// expression shall not match [first, first).
+  static const match_flag_type match_not_bol     = 1 << _S_not_bol;
+
+  /// The last character in the sequence [first, last) is treated as though it
+  /// is not at the end of a line, so the character "$" in the regular
+  /// expression shall not match [last, last).
+  static const match_flag_type match_not_eol     = 1 << _S_not_eol;
+   
+  /// The expression "\b" is not matched against the sub-sequence
+  /// [first,first).
+  static const match_flag_type match_not_bow     = 1 << _S_not_bow;
+   
+  /// The expression "\b" should not be matched against the sub-sequence
+  /// [last,last).
+  static const match_flag_type match_not_eow     = 1 << _S_not_eow;
+   
+  /// If more than one match is possible then any match is an acceptable
+  /// result.
+  static const match_flag_type match_any         = 1 << _S_any;
+   
+  /// The expression does not match an empty sequence.
+  static const match_flag_type match_not_null    = 1 << _S_not_null;
+   
+  /// The expression only matchs a sub-sequence that begins at first .
+  static const match_flag_type match_continuous  = 1 << _S_continuous;
+   
+  /// --first is a valid iterator position.  When this flag is set then the
+  /// flags match_not_bol and match_not_bow are ignored by the regular
+  /// expression algorithms 7.11 and iterators 7.12.
+  static const match_flag_type match_prev_avail  = 1 << _S_prev_avail;
+
+  /// When a regular expression match is to be replaced by a new string, the
+  /// new string is constructed using the rules used by the ECMAScript replace
+  /// function in ECMA- 262 [Ecma International, ECMAScript Language
+  /// Specification, Standard Ecma-262, third edition, 1999], part 15.5.4.11
+  /// String.prototype.replace. In addition, during search and replace
+  /// operations all non-overlapping occurrences of the regular expression
+  /// are located and replaced, and sections of the input that did not match
+  /// the expression are copied unchanged to the output string.
+  ///
+  /// Format strings (from ECMA-262 [15.5.4.11]):
+  /// $$  $
+  /// $&  The matched substring.
+  /// $`  The portion of <em>string</em> that preceeds the matched substring.
+  /// $'  The portion of <em>string</em> that follows the matched substring.
+  /// $n  The nth capture, where n is in [1,9] and $n is not followed by a
+  ///     decimal digit.  If n <= m and the nth capture is undefined, use the
+  ///     empty string
+  ///     instead. If n > m, the result is implementation-defined.
+  /// $nn The nnth capture, where nn is a two-digit decimal number on [01, 99].
+  ///     If nn <= m and the nth capture is undefined, use the empty string
+  ///     instead. If nn > m, the result is implementation-defined.
+  ///
+  static const match_flag_type format_default    = 0;
+
+  /// When a regular expression match is to be replaced by a new string, the
+  /// new string is constructed using the rules used by the POSIX sed utility
+  /// in IEEE Std 1003.1- 2001 [IEEE, Information Technology -- Portable
+  /// Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
+  static const match_flag_type format_sed        = 1 << _S_sed;
+
+  /// During a search and replace operation, sections of the character
+  /// container sequence being searched that do not match the regular
+  /// expression shall not be copied to the output string.
+  static const match_flag_type format_no_copy    = 1 << _S_no_copy;
+
+  /// When specified during a search and replace operation, only the first
+  /// occurrence of the regular expression shall be replaced.
+  static const match_flag_type format_first_only = 1 << _S_first_only;
+
+
+  // [7.5.3] implementation-defined error type
+  enum error_type
+    {
+      _S_error_collate,
+      _S_error_ctype,
+      _S_error_escape,
+      _S_error_backref,
+      _S_error_brack,
+      _S_error_paren,
+      _S_error_brace,
+      _S_error_badbrace,
+      _S_error_range,
+      _S_error_space,
+      _S_error_badrepeat,
+      _S_error_complexity,
+      _S_error_stack,
+      _S_error_last
+    };
+
+  /// The expression contained an invalid collating element name.
+  static const error_type error_collate(_S_error_collate);
+
+  /// The expression contained an invalid character class name.
+  static const error_type error_ctype(_S_error_ctype);
+
+  /// The expression contained an invalid escaped character, or a trailing
+  /// escape.
+  static const error_type error_escape(_S_error_escape);
+
+  /// The expression contained an invalid back reference.
+  static const error_type error_backref(_S_error_backref);
+
+  /// The expression contained mismatched [ and ].
+  static const error_type error_brack(_S_error_brack);
+
+  /// The expression contained mismatched ( and ).
+  static const error_type error_paren(_S_error_paren);
+
+  /// The expression contained mismatched { and }
+  static const error_type error_brace(_S_error_brace);
+
+  /// The expression contained an invalid range in a {} expression.
+  static const error_type error_badbrace(_S_error_badbrace);
+
+  /// The expression contained an invalid character range,
+  /// such as [b-a] in most encodings.
+  static const error_type error_range(_S_error_range);
+
+  /// There was insufficient memory to convert the expression into a
+  /// finite state machine.
+  static const error_type error_space(_S_error_space);
+
+  /// One of *?+{ was not preceded by a valid regular expression.
+  static const error_type error_badrepeat(_S_error_badrepeat);
+
+  /// The complexity of an attempted match against a regular expression
+  /// exceeded a pre-set level.
+  static const error_type error_complexity(_S_error_complexity);
+
+  /// There was insufficient memory to determine whether the
+  /// regular expression could match the specified character sequence.
+  static const error_type error_stack(_S_error_stack);
+}
+
+
+  // [7.8] Class regex_error
+  /**
+   * Defines the type of objects thrown as exceptions to report errors from the
+   * regular expression library.
+   */
+  class regex_error
+  : public std::runtime_error
+  {
+  public:
+    /**
+     * @brief constructs a regex_error object.
+     *
+     * @param ecode the regex error code.
+     */
+    explicit
+    regex_error(regex_constants::error_type __ecode)
+    : std::runtime_error("regex_error"), _M_code(__ecode)
+    { }
+
+    /**
+     * @brief gets the regex error code.
+     *
+     * @returns the regex error code.
+     */
+    regex_constants::error_type
+    code() const
+    { return _M_code; }
+
+  protected:
+    regex_constants::error_type _M_code;
+  };
+
+
+  // [7.7] Class regex_traits
+  /**
+   * A regular expression traits class that satisfies the requirements of tr1
+   * section [7.2].
+   *
+   * The class %regex is parameterized around a set of related types and
+   * functions used to complete the definition of its semantics.  This class
+   * satisfies the requirements of such a traits class.
+   */
+  template<typename _Ch_type>
+    struct regex_traits
+    {
+    public:
+      typedef _Ch_type                     char_type;
+      typedef std::basic_string<char_type> string_type;
+      typedef std::locale                  locale_type;
+      typedef std::ctype_base::mask        char_class_type;
+
+    public:
+      /**
+       * @brief Constructs a default traits object.
+       */
+      regex_traits()
+      { }
+      
+      /**
+       * @brief Gives the length of a C-style string starting at @p __p.
+       *
+       * @param __p a pointer to the start of a character sequence.
+       *
+       * @returns the number of characters between @p *__p and the first
+       * default-initialized value of type @p char_type.  In other words, uses
+       * the C-string algorithm for determiining the length of a sequence of
+       * characters.
+       */
+      static std::size_t
+      length(const char_type* __p)
+      { return string_type::traits_type::length(__p); }
+
+      /**
+       * @brief Performs the identity translation.
+       *
+       * @param c A character to the locale-specific character set.
+       *
+       * @returns c.
+       */
+      char_type
+      translate(char_type __c) const
+      { return __c; }
+      
+      /**
+       * @brief Translates a character into a case-insensitive equivalent.
+       *
+       * @param c A character to the locale-specific character set.
+       *
+       * @returns the locale-specific lower-case equivalent of c.
+       * @throws std::bad_cast if the imbued locale does not support the ctype
+       *         facet.
+       */
+      char_type
+      translate_nocase(char_type __c) const
+      {
+	using std::ctype;
+	using std::use_facet;
+	return use_facet<ctype<char_type> >(_M_locale).tolower(__c);
+      }
+      
+      /**
+       * @brief Gets a sort key for a character sequence.
+       *
+       * @param first beginning of the character sequence.
+       * @param last  one-past-the-end of the character sequence.
+       *
+       * Returns a sort key for the character sequence designated by the
+       * iterator range [F1, F2) such that if the character sequence [G1, G2)
+       * sorts before the character sequence [H1, H2) then
+       * v.transform(G1, G2) < v.transform(H1, H2).
+       *
+       * What this really does is provide a more efficient way to compare a
+       * string to multiple other strings in locales with fancy collation
+       * rules and equivalence classes.
+       *
+       * @returns a locale-specific sort key equivalent to the input range.
+       *
+       * @throws std::bad_cast if the current locale does not have a collate
+       *         facet.
+       */
+      template<typename _Fwd_iter>
+        string_type
+        transform(_Fwd_iter __first, _Fwd_iter __last) const
+        {
+	  using std::collate;
+	  using std::use_facet;
+	  const collate<_Ch_type>& __c(use_facet<
+				       collate<_Ch_type> >(_M_locale));
+	  string_type __s(__first, __last);
+	  return __c.transform(__s.data(), __s.data() + __s.size());
+	}
+
+      /**
+       * @brief Dunno.
+       *
+       * @param first beginning of the character sequence.
+       * @param last  one-past-the-end of the character sequence.
+       *
+       * Effects: if typeid(use_facet<collate<_Ch_type> >) ==
+       * typeid(collate_byname<_Ch_type>) and the form of the sort key
+       * returned by collate_byname<_Ch_type>::transform(first, last) is known
+       * and can be converted into a primary sort key then returns that key,
+       * otherwise returns an empty string. WTF??
+       *
+       * @todo Implement this function.
+       */
+      template<typename _Fwd_iter>
+        string_type
+        transform_primary(_Fwd_iter __first, _Fwd_iter __last) const
+        { return string_type(); }
+
+      /**
+       * @breief Gets a collation element by name.
+       *
+       * @param first beginning of the collation element name.
+       * @param last  one-past-the-end of the collation element name.
+       * 
+       * @returns a sequence of one or more characters that represents the
+       * collating element consisting of the character sequence designated by
+       * the iterator range [first, last). Returns an empty string if the
+       * character sequence is not a valid collating element.
+       *
+       * @todo Implement this function.
+       */
+      template<typename _Fwd_iter>
+        string_type
+        lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const
+        { return string_type(); }
+
+      /**
+       * @brief Maps one or mire characters to a named character
+       *        classification.
+       *
+       * @param first beginning of the character sequence.
+       * @param last  one-past-the-end of the character sequence.
+       *
+       * @returns an unspecified value that represents the character
+       * classification named by the character sequence designated by the
+       * iterator range [first, last). The value returned shall be independent
+       * of the case of the characters in the character sequence. If the name
+       * is not recognized then returns a value that compares equal to 0.
+       *
+       * At least the following names (or their wide-character equivalent) are
+       * supported.
+       * - d
+       * - w
+       * - s
+       * - alnum
+       * - alpha
+       * - blank
+       * - cntrl
+       * - digit
+       * - graph
+       * - lower
+       * - print
+       * - punct
+       * - space
+       * - upper
+       * - xdigit
+       *
+       * @todo Implement this function.
+       */
+      template<typename _Fwd_iter>
+        char_class_type
+        lookup_classname(_Fwd_iter __first, _Fwd_iter __last) const
+        { return 0; }
+
+      /**
+       * @brief Determines if @p c is a member of an identified class.
+       *
+       * @param c a character.
+       * @param f a class type (as returned from lookup_classname).
+       *
+       * @returns true if the character @p c is a member of the classification
+       * represented by @p f, false otherwise.
+       *
+       * @throws std::bad_cast if the current locale does not have a ctype
+       *         facet.
+       */
+      bool
+      isctype(_Ch_type __c, char_class_type __f) const
+      {
+	using std::ctype;
+	using std::use_facet;
+	const ctype<_Ch_type>& __ctype(use_facet<
+				       ctype<_Ch_type> >(_M_locale));
+	
+	if (__ctype.is(__c, __f))
+	  return true;
+	
+	// special case of underscore in [[:w:]]
+	if (__c == __ctype.widen('_'))
+	  {
+	    const char* const __wb[] = "w";
+	    char_class_type __wt = this->lookup_classname(__wb,
+							  __wb + sizeof(__wb));
+	    if (__f | __wt)
+	      return true;
+	  }
+      
+	// special case of [[:space:]] in [[:blank:]]
+	if (__c == __ctype.isspace(__c))
+	  {
+	    const char* const __bb[] = "blank";
+	    char_class_type __bt = this->lookup_classname(__bb,
+							  __bb + sizeof(__bb));
+	    if (__f | __bt)
+	      return true;
+	  }
+	
+	return false;
+      }
+
+      /**
+       * @brief Converts a digit to an int.
+       *
+       * @param ch    a character representing a digit.
+       * @param radix the radix if the numeric conversion (limited to 8, 10,
+       *              or 16).
+       * 
+       * @returns the value represented by the digit ch in base radix if the
+       * character ch is a valid digit in base radix; otherwise returns -1.
+       *
+       * @todo Implement this function.
+       */
+      int
+      value(_Ch_type __ch, int __radix) const;
+      
+      /**
+       * @brief Imbues the regex_traits object with a copy of a new locale.
+       *
+       * @param loc A locale.
+       *
+       * @returns a copy of the previous locale in use by the regex_traits
+       *          object.
+       *
+       * @note Calling imbue with a different locale than the one currently in
+       *       use invalidates all cached data held by *this.
+       */
+      locale_type
+      imbue(locale_type __loc)
+      {
+	std::swap(_M_locale, __loc);
+	return __loc;
+      }
+      
+      /**
+       * @brief Gets a copy of the current locale in use by the regex_traits
+       * object.
+       */
+      locale_type
+      getloc() const
+      { return _M_locale; }
+      
+    protected:
+      locale_type _M_locale;
+    };
+
+
+  // [7.8] Class basic_regex
+  /**
+   * Objects of specializations of this class represent regular expressions
+   * constructed from sequences of character type @p _Ch_type.
+   *
+   * Storage for the regular expression is allocated and deallocated as
+   * necessary by the member functions of this class.
+   */
+  template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type> >
+    class basic_regex
+    {
+    public:
+      // types:
+      typedef _Ch_type                              value_type;
+      typedef regex_constants::syntax_option_type flag_type;
+      typedef typename _Rx_traits::locale_type  locale_type;
+      typedef typename _Rx_traits::string_type  string_type;
+
+      // [7.8.1] constants
+      static const regex_constants::syntax_option_type icase
+        = regex_constants::icase;
+      static const regex_constants::syntax_option_type nosubs
+        = regex_constants::nosubs;
+      static const regex_constants::syntax_option_type optimize
+        = regex_constants::optimize;
+      static const regex_constants::syntax_option_type collate
+        = regex_constants::collate;
+      static const regex_constants::syntax_option_type ECMAScript
+        = regex_constants::ECMAScript;
+      static const regex_constants::syntax_option_type basic
+        = regex_constants::basic;
+      static const regex_constants::syntax_option_type extended
+        = regex_constants::extended;
+      static const regex_constants::syntax_option_type awk
+        = regex_constants::awk;
+      static const regex_constants::syntax_option_type grep
+        = regex_constants::grep;
+      static const regex_constants::syntax_option_type egrep
+        = regex_constants::egrep;
+
+      // [7.8.2] construct/copy/destroy
+      /**
+       * Constructs a basic regular expression that does not match any
+       * character sequence.
+       */
+      basic_regex()
+      : _M_flags(regex_constants::ECMAScript), _M_pattern(), _M_mark_count(0)
+      { _M_compile(); }
+
+      /**
+       * @brief Constructs a basic regular expression from the sequence
+       * [p, p + char_traits<_Ch_type>::length(p)) interpreted according to the
+       * flags in @p f.
+       *
+       * @param p A pointer to the start of a C-style null-terminated string
+       *          containing a regular expression.
+       * @param f Flags indicating the syntax rules and options.
+       *
+       * @throws regex_error if @p p is not a valid regular expression.
+       */
+      explicit
+      basic_regex(const _Ch_type* __p,
+		  flag_type __f = regex_constants::ECMAScript)
+      : _M_flags(__f), _M_pattern(__p), _M_mark_count(0)
+      { _M_compile(); }
+
+      /**
+       * @brief Constructs a basic regular expression from the sequence
+       * [p, p + len) interpreted according to the flags in @p f.
+       *
+       * @param p   A pointer to the start of a string containing a regular
+       *            expression.
+       * @param len The length of the string containing the regular expression.
+       * @param f   Flags indicating the syntax rules and options.
+       *
+       * @throws regex_error if @p p is not a valid regular expression.
+       */
+      basic_regex(const _Ch_type* __p, std::size_t __len, flag_type __f)
+      : _M_flags(__f) , _M_pattern(__p, __len), _M_mark_count(0)
+      { _M_compile(); }
+
+      /**
+       * @brief Copy-contructs a basic regular expression.
+       *
+       * @param rhs A @p regex object.
+     */
+      basic_regex(const basic_regex& __rhs)
+      : _M_flags(__rhs._M_flags), _M_pattern(__rhs._M_pattern),
+	_M_mark_count(__rhs._M_mark_count)
+      { _M_compile(); }
+
+      /**
+       * @brief Constructs a basic regular expression from the string
+       * @p interpreted according to the flags in @p f.
+       *
+       * @param p A string containing a regular expression.
+       * @param f Flags indicating the syntax rules and options.
+       *
+       * @throws regex_error if @p p is not a valid regular expression.
+       */
+      template<typename _Ch_traits, typename _Ch_alloc>
+        explicit
+        basic_regex(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
+		    flag_type __f = regex_constants::ECMAScript)
+	: _M_flags(__f), _M_pattern(__s), _M_mark_count(0)
+        { _M_compile(); }
+
+      /**
+       * @brief Constructs a basic regular expression from the range
+       * [first, last) interpreted according to the flags in @p f.
+       *
+       * @param first The start of arange containing a valid regular
+       *              expression.
+       * @param last  The end of a range containing a valid regular
+       *              expression.
+       * @param f     The format flags of the regular expression.
+       *
+       * @throws regex_error if @p p is not a valid regular expression.
+       */
+      template<typename _InputIterator>
+        basic_regex(_InputIterator __first, _InputIterator __last, 
+		    flag_type __f = regex_constants::ECMAScript)
+	: _M_flags(__f), _M_pattern(__first, __last), _M_mark_count(0)
+        { _M_compile(); }
+
+      /**
+       * @brief Destroys a basic regular expression.
+       */
+      ~basic_regex()
+      { }
+      
+      /**
+       * @brief Assigns one regular expression to another.
+       */
+      basic_regex&
+      operator=(const basic_regex& __rhs)
+      { return this->assign(__rhs); }
+
+      /**
+       * @brief Replaces a regular expression with a new one constructed from
+       * a C-style null-terminated string.
+       *
+       * @param A pointer to the start of a null-terminated C-style string
+       *        containing a regular expression.
+       */
+      basic_regex&
+      operator=(const _Ch_type* __p)
+      { return this->assign(__p, flags()); }
+      
+      /**
+       * @brief Replaces a regular expression with a new one constructed from
+       * a string.
+       *
+       * @param A pointer to a string containing a regular expression.
+       */
+      template<typename _Ch_typeraits, typename _Allocator>
+        basic_regex&
+        operator=(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s)
+        { return this->assign(__s, flags()); }
+
+      // [7.8.3] assign
+      /**
+       * @brief the real assignment operator.
+       *
+       * @param that Another regular expression object.
+       */
+      basic_regex&
+      assign(const basic_regex& __that)
+      {
+	basic_regex __tmp(__that);
+	this->swap(__tmp);
+	return *this;
+      }
+      
+      /**
+       * @brief Assigns a new regular expression to a regex object from a
+       * C-style null-terminated string containing a regular expression
+       * pattern.
+       *
+       * @param p     A pointer to a C-style null-terminated string containing
+       *              a regular expression pattern.
+       * @param flags Syntax option flags.
+       *
+       * @throws regex_error if p does not contain a valid regular expression
+       * pattern interpreted according to @p flags.  If regex_error is thrown,
+       * *this remains unchanged.
+       */
+      basic_regex&
+      assign(const _Ch_type* __p,
+	     flag_type __flags = regex_constants::ECMAScript)
+      { return this->assign(string_type(__p), __flags); }
+
+      /**
+       * @brief Assigns a new regular expression to a regex object from a
+       * C-style string containing a regular expression pattern.
+       *
+       * @param p     A pointer to a C-style string containing a
+       *              regular expression pattern.
+       * @param len   The length of the regular expression pattern string.
+       * @param flags Syntax option flags.
+       *
+       * @throws regex_error if p does not contain a valid regular expression
+       * pattern interpreted according to @p flags.  If regex_error is thrown,
+       * *this remains unchanged.
+       */
+      basic_regex&
+      assign(const _Ch_type* __p, std::size_t __len, flag_type __flags)
+      { return this->assign(string_type(__p, __len), __flags); }
+
+      /**
+       * @brief Assigns a new regular expression to a regex object from a 
+       * string containing a regular expression pattern.
+       *
+       * @param s     A string containing a regular expression pattern.
+       * @param flags Syntax option flags.
+       *
+       * @throws regex_error if p does not contain a valid regular expression
+       * pattern interpreted according to @p flags.  If regex_error is thrown,
+       * *this remains unchanged.
+       */
+      template<typename _Ch_typeraits, typename _Allocator>
+        basic_regex&
+        assign(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s,
+	       flag_type __f = regex_constants::ECMAScript)
+        { 
+	  basic_regex __tmp(__s, __f);
+	  this->swap(__tmp);
+	  return *this;
+	}
+
+      /**
+       * @brief Assigns a new regular expression to a regex object.
+       *
+       * @param first The start of a range containing a valid regular
+       *              expression.
+       * @param last  The end of a range containing a valid regular
+       *              expression.
+       * @param flags Syntax option flags.
+       *
+       * @throws regex_error if p does not contain a valid regular expression
+       * pattern interpreted according to @p flags.  If regex_error is thrown,
+       * *this remains unchanged.
+       */
+      template<typename _InputIterator>
+        basic_regex&
+        assign(_InputIterator __first, _InputIterator __last,
+	       flag_type __flags = regex_constants::ECMAScript)
+        { return this->assign(string_type(__first, __last), __flags); }
+
+      // [7.8.4] const operations
+      /**
+       * @brief Gets the number of marked subexpressions within the regular
+       * expresison.
+       */
+      unsigned int
+      mark_count() const
+      { return _M_mark_count; }
+      
+      /**
+       * @brief Gets the flags used to construct the regular expression
+       * or in the last call to assign().
+       */
+      flag_type
+      flags() const
+      { return _M_flags; }
+      
+      // [7.8.5] locale
+      /**
+       * @brief Imbues the regular expression object with the given locale.
+       *
+       * @param loc A locale.
+       */
+      locale_type
+      imbue(locale_type __loc)
+      { return _M_traits.imbue(__loc); }
+      
+      /**
+       * @brief Gets the locale currently imbued in the regular expression
+       *        object.
+       */
+      locale_type
+      getloc() const
+      { return _M_traits.getloc(); }
+      
+      // [7.8.6] swap
+      /**
+       * @brief Swaps the contents of two regular expression obects.
+       *
+       * @param rhs Another regular expression object.
+       */
+      void
+      swap(basic_regex& __rhs)
+      {
+	std::swap(_M_flags,      __rhs._M_flags);
+	std::swap(_M_pattern,    __rhs._M_pattern);
+	std::swap(_M_mark_count, __rhs._M_mark_count);
+	std::swap(_M_traits,     __rhs._M_traits);
+      }
+      
+    private:
+      /**
+       * @brief Compiles a regular expression pattern into a NFA.
+       * @todo Implement this function.
+       */
+      void _M_compile()
+      { }
+
+    protected:
+      flag_type    _M_flags;
+      string_type  _M_pattern;
+      unsigned int _M_mark_count;
+      _Rx_traits   _M_traits;
+    };
+  
+  typedef basic_regex<char>    regex;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  typedef basic_regex<wchar_t> wregex;
+#endif
+
+
+  // [7.8.6] basic_regex swap
+  /**
+   * @brief Swaps the contents of two regular expression objects.
+   * @param lhs First regular expression.
+   * @param rhs Second regular expression.
+   */
+  template<typename _Ch_type, typename _Rx_traits>
+    inline void
+    swap(basic_regex<_Ch_type, _Rx_traits>& __lhs,
+	 basic_regex<_Ch_type, _Rx_traits>& __rhs)
+    { return __lhs.swap(__rhs); }
+
+
+  // [7.9] Class template sub_match
+  /**
+   * A sequence of characters matched by a particular marked sub-expression.
+   *
+   * An object of this class is essentially a pair of iterators marking a
+   * matched subexpression within a regular expression pattern match. Such
+   * objects can be converted to and compared with std::basic_string objects
+   * of a similar base character type as the pattern matched by the regular
+   * expression.
+   *
+   * The iterators that make up the pair are the usual half-open interval
+   * referencing the actual original pattern matched.
+   */
+  template<typename _BiIter>
+    class sub_match : public std::pair<_BiIter, _BiIter>
+    {
+    public:
+      typedef typename iterator_traits<_BiIter>::value_type      value_type;
+      typedef typename iterator_traits<_BiIter>::difference_type
+                                                            difference_type;
+      typedef _BiIter                                              iterator;
+
+    public:
+      bool matched;
+      
+      /**
+       * Gets the length of the matching sequence.
+       */
+      difference_type
+      length() const
+      { return this->matched ? std::distance(this->first, this->second) : 0; }
+
+      /**
+       * @brief Gets the matching sequence as a string.
+       *
+       * @returns the matching sequence as a string.
+       *
+       * This is the implicit conversion operator.  It is identical to the
+       * str() member function except that it will want to pop up in
+       * unexpected places and cause a great deal of confusion and cursing
+       * from the unwary.
+       */
+      operator basic_string<value_type>() const
+      {
+	return this->matched
+	  ? std::basic_string<value_type>(this->first, this->second)
+	  : std::basic_string<value_type>();
+      }
+      
+      /**
+       * @brief Gets the matching sequence as a string.
+       *
+       * @returns the matching sequence as a string.
+       */
+      basic_string<value_type>
+      str() const
+      {
+	return this->matched
+	  ? std::basic_string<value_type>(this->first, this->second)
+	  : std::basic_string<value_type>();
+      }
+      
+      /**
+       * @brief Compares this and another matched sequence.
+       *
+       * @param s Another matched sequence to compare to this one.
+       *
+       * @retval <0 this matched sequence will collate before @p s.
+       * @retval =0 this matched sequence is equivalent to @p s.
+       * @retval <0 this matched sequence will collate after @p s.
+       */
+      int
+      compare(const sub_match& __s) const
+      { return this->str().compare(__s.str()); }
+
+      /**
+       * @brief Compares this sub_match to a string.
+       *
+       * @param s A string to compare to this sub_match.
+       *
+       * @retval <0 this matched sequence will collate before @p s.
+       * @retval =0 this matched sequence is equivalent to @p s.
+       * @retval <0 this matched sequence will collate after @p s.
+       */
+      int
+      compare(const basic_string<value_type>& __s) const
+      { return this->str().compare(__s); }
+      
+      /**
+       * @brief Compares this sub_match to a C-style string.
+       *
+       * @param s A C-style string to compare to this sub_match.
+       *
+       * @retval <0 this matched sequence will collate before @p s.
+       * @retval =0 this matched sequence is equivalent to @p s.
+       * @retval <0 this matched sequence will collate after @p s.
+       */
+      int
+      compare(const value_type* __s) const
+      { return this->str().compare(__s); }
+    };
+  
+  
+  typedef sub_match<const char*>             csub_match;
+  typedef sub_match<string::const_iterator>  ssub_match;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  typedef sub_match<const wchar_t*>          wcsub_match;
+  typedef sub_match<wstring::const_iterator> wssub_match;
+#endif
+
+  // [7.9.2] sub_match non-member operators
+  
+  /**
+   * @brief Tests the equivalence of two regular expression submatches.
+   * @param lhs First regular expression submatch.
+   * @param rhs Second regular expression submatch.
+   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
+   */
+  template<typename _BiIter>
+    inline bool
+    operator==(const sub_match<_BiIter>& __lhs,
+	       const sub_match<_BiIter>& __rhs)
+    { return __lhs.compare(__rhs) == 0; }
+
+  /**
+   * @brief Tests the inequivalence of two regular expression submatches.
+   * @param lhs First regular expression submatch.
+   * @param rhs Second regular expression submatch.
+   * @returns true if @a lhs  is not equivalent to @a rhs, false otherwise.
+   */
+  template<typename _BiIter>
+    inline bool
+    operator!=(const sub_match<_BiIter>& __lhs,
+	       const sub_match<_BiIter>& __rhs)
+    { return __lhs.compare(__rhs) != 0; }
+
+  /**
+   * @brief Tests the ordering of two regular expression submatches.
+   * @param lhs First regular expression submatch.
+   * @param rhs Second regular expression submatch.
+   * @returns true if @a lhs precedes @a rhs, false otherwise.
+   */
+  template<typename _BiIter>
+    inline bool
+    operator<(const sub_match<_BiIter>& __lhs,
+	      const sub_match<_BiIter>& __rhs)
+    { return __lhs.compare(__rhs) < 0; }
+
+  /**
+   * @brief Tests the ordering of two regular expression submatches.
+   * @param lhs First regular expression submatch.
+   * @param rhs Second regular expression submatch.
+   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+   */
+  template<typename _BiIter>
+    inline bool
+    operator<=(const sub_match<_BiIter>& __lhs,
+	       const sub_match<_BiIter>& __rhs)
+    { return __lhs.compare(__rhs) <= 0; }
+
+  /**
+   * @brief Tests the ordering of two regular expression submatches.
+   * @param lhs First regular expression submatch.
+   * @param rhs Second regular expression submatch.
+   * @returns true if @a lhs does not preceed @a rhs, false otherwise.
+   */
+  template<typename _BiIter>
+    inline bool
+    operator>=(const sub_match<_BiIter>& __lhs,
+	       const sub_match<_BiIter>& __rhs)
+    { return __lhs.compare(__rhs) >= 0; }
+
+  /**
+   * @brief Tests the ordering of two regular expression submatches.
+   * @param lhs First regular expression submatch.
+   * @param rhs Second regular expression submatch.
+   * @returns true if @a lhs succeeds @a rhs, false otherwise.
+   */
+  template<typename _BiIter>
+    inline bool
+    operator>(const sub_match<_BiIter>& __lhs,
+	      const sub_match<_BiIter>& __rhs)
+    { return __lhs.compare(__rhs) > 0; }
+
+  /**
+   * @brief Tests the equivalence of a string and a regular expression
+   *        submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator==(const basic_string<
+	       typename iterator_traits<_Bi_iter>::value_type,
+	       _Ch_traits, _Ch_alloc>& __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __lhs == __rhs.str(); }
+
+  /**
+   * @brief Tests the inequivalence of a string and a regular expression
+   *        submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs  is not equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator!=(const basic_string<
+	       typename iterator_traits<_Bi_iter>::value_type,
+	       _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
+    { return __lhs != __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs precedes @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator<(const basic_string<
+	      typename iterator_traits<_Bi_iter>::value_type,
+	      _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
+     { return __lhs < __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs succeeds @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator>(const basic_string<
+	      typename iterator_traits<_Bi_iter>::value_type, 
+	      _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
+    { return __lhs > __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs does not preceed @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator>=(const basic_string<
+	       typename iterator_traits<_Bi_iter>::value_type,
+	       _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
+    { return __lhs >= __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator<=(const basic_string<
+	       typename iterator_traits<_Bi_iter>::value_type,
+	       _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
+    { return __lhs <= __rhs.str(); }
+
+  /**
+   * @brief Tests the equivalence of a regular expression submatch and a
+   *        string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator==(const sub_match<_Bi_iter>& __lhs,
+	       const basic_string<
+	       typename iterator_traits<_Bi_iter>::value_type,
+	       _Ch_traits, _Ch_alloc>& __rhs)
+    { return __lhs.str() == __rhs; }
+
+  /**
+   * @brief Tests the inequivalence of a regular expression submatch and a
+   *        string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator!=(const sub_match<_Bi_iter>& __lhs,
+	       const basic_string<
+	       typename iterator_traits<_Bi_iter>::value_type,
+	       _Ch_traits, _Ch_alloc>& __rhs)
+    { return __lhs.str() != __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs precedes @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+    inline bool
+    operator<(const sub_match<_Bi_iter>& __lhs,
+	      const basic_string<
+	      typename iterator_traits<_Bi_iter>::value_type,
+	      _Ch_traits, _Ch_alloc>& __rhs)
+    { return __lhs.str() < __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs succeeds @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+    inline bool
+    operator>(const sub_match<_Bi_iter>& __lhs,
+	      const basic_string<
+	      typename iterator_traits<_Bi_iter>::value_type,
+	      _Ch_traits, _Ch_alloc>& __rhs)
+    { return __lhs.str() > __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs does not preceed @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+    inline bool
+    operator>=(const sub_match<_Bi_iter>& __lhs,
+	       const basic_string<
+	       typename iterator_traits<_Bi_iter>::value_type,
+	       _Ch_traits, _Ch_alloc>& __rhs)
+    { return __lhs.str() >= __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+    inline bool
+    operator<=(const sub_match<_Bi_iter>& __lhs,
+	       const basic_string<
+	       typename iterator_traits<_Bi_iter>::value_type,
+	       _Ch_traits, _Ch_alloc>& __rhs)
+    { return __lhs.str() <= __rhs; }
+
+  /**
+   * @brief Tests the equivalence of a C string and a regular expression
+   *        submatch.
+   * @param lhs A C string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator==(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __lhs == __rhs.str(); }
+
+  /**
+   * @brief Tests the inequivalence of an iterator value and a regular
+   *        expression submatch.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator!=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __lhs != __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs precedes @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+	      const sub_match<_Bi_iter>& __rhs)
+    { return __lhs < __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs succeeds @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+	      const sub_match<_Bi_iter>& __rhs)
+    { return __lhs > __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs does not preceed @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __lhs >= __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __lhs <= __rhs.str(); }
+
+  /**
+   * @brief Tests the equivalence of a regular expression submatch and a
+   *        string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A pointer to a string?
+   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator==(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+    { return __lhs.str() == __rhs; }
+
+  /**
+   * @brief Tests the inequivalence of a regular expression submatch and a
+   *        string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A pointer to a string.
+   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator!=(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+    { return __lhs.str() != __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs precedes @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<(const sub_match<_Bi_iter>& __lhs,
+	      typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+    { return __lhs.str() < __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs succeeds @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>(const sub_match<_Bi_iter>& __lhs,
+	      typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+    { return __lhs.str() > __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs does not precede @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>=(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+    { return __lhs.str() >= __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<=(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+    { return __lhs.str() <= __rhs; }
+
+  /**
+   * @brief Tests the equivalence of a string and a regular expression
+   *        submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator==(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __lhs == __rhs.str(); }
+
+  /**
+   * @brief Tests the inequivalence of a string and a regular expression
+   *        submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator!=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __lhs != __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs precedes @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+	      const sub_match<_Bi_iter>& __rhs)
+    { return __lhs < __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs succeeds @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+	      const sub_match<_Bi_iter>& __rhs)
+    { return __lhs > __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs does not preceed @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __lhs >= __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __lhs <= __rhs.str(); }
+
+  /**
+   * @brief Tests the equivalence of a regular expression submatch and a
+   *        string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A const string reference.
+   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator==(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+    { return __lhs.str() == __rhs; }
+
+  /**
+   * @brief Tests the inequivalence of a regular expression submatch and a
+   *        string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A const string reference.
+   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator!=(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+    { return __lhs.str() != __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A const string reference.
+   * @returns true if @a lhs preceeds @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<(const sub_match<_Bi_iter>& __lhs,
+	      typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+    { return __lhs.str() < __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A const string reference.
+   * @returns true if @a lhs succeeds @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>(const sub_match<_Bi_iter>& __lhs,
+	      typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+    { return __lhs.str() > __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A const string reference.
+   * @returns true if @a lhs does not preceed @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>=(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+    { return __lhs.str() >= __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A const string reference.
+   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<=(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+    { return __lhs.str() <= __rhs; }
+
+  /**
+   * @brief Inserts a matched string into an output stream.
+   *
+   * @param os The output stream.
+   * @param m  A submatch string.
+   *
+   * @returns the output stream with the submatch string inserted.
+   */
+  template<typename _Ch_type, typename _Ch_traits, typename _Bi_iter>
+    inline
+    basic_ostream<_Ch_type, _Ch_traits>&
+    operator<<(basic_ostream<_Ch_type, _Ch_traits>& __os,
+	       const sub_match<_Bi_iter>& __m)
+    { return __os << __m.str(); }
+
+  // [7.10] Class template match_results
+  /**
+   * A collection of character sequences representing the result of a regular
+   * expression match.  Storage for the collection is allocated and freed as
+   * necessary by the member functions of class template match_results.
+   *
+   * This class satisfies the Sequence requirements, with the exception that
+   * only the operations defined for a const-qualified Sequence are supported.
+   *
+   * The sub_match object stored at index 0 represents sub-expression 0, i.e.
+   * the whole match. In this case the sub_match member matched is always true.
+   * The sub_match object stored at index n denotes what matched the marked
+   * sub-expression n within the matched expression. If the sub-expression n
+   * participated in a regular expression match then the sub_match member
+   * matched evaluates to true, and members first and second denote the range
+   * of characters [first, second) which formed that match. Otherwise matched
+   * is false, and members first and second point to the end of the sequence
+   * that was searched.
+   */
+  template<typename _Bi_iter,
+	   typename _Allocator = allocator<sub_match<_Bi_iter> > >
+    class match_results
+    : private std::vector<std::_GLIBCXX_TR1 sub_match<_Bi_iter>, _Allocator>
+    {
+    private:
+      typedef std::vector<std::_GLIBCXX_TR1 sub_match<_Bi_iter>, _Allocator>
+                                                              _Base_type;
+
+    public:
+      typedef sub_match<_Bi_iter>                             value_type;
+      typedef typename _Allocator::const_reference            const_reference;
+      typedef const_reference                                 reference;
+      typedef typename _Base_type::const_iterator             const_iterator;
+      typedef const_iterator                                  iterator;
+      typedef typename iterator_traits<_Bi_iter>::difference_type
+                                                              difference_type;
+      typedef typename _Allocator::size_type                  size_type;
+      typedef _Allocator                                      allocator_type;
+      typedef typename iterator_traits<_Bi_iter>::value_type  char_type;
+      typedef basic_string<char_type>                         string_type;
+  
+    public:
+      // [7.10.1] construct/copy/destroy
+      /**
+       * @brief Constructs a default match_results container.
+       */
+      explicit
+      match_results(const _Allocator& __a = _Allocator())
+      : _Base_type(__a), _M_matched(false)
+      { }
+
+      /**
+       * @brief Copy constructs a match_result.
+       */
+      match_results(const match_results& __rhs)
+      : _Base_type(__rhs), _M_matched(__rhs._M_matched),
+	_M_prefix(__rhs._M_prefix), _M_suffix(__rhs._M_suffix)
+      { }
+
+      /**
+       * @brief Assigns rhs to *this.
+       */
+      match_results&
+      operator=(const match_results& __rhs)
+      {
+	match_results __tmp(__rhs);
+	this->swap(__tmp);
+      }
+
+      /**
+       * @todo Implement this function.
+       */
+      ~match_results()
+      { }
+      
+      // [7.10.2] size
+      /**
+       * @todo Document this function.
+       */
+      size_type
+      size() const
+      { return _M_matched ? _Base_type::size() + 1 : 0; }
+      
+      /**
+       * @todo Implement this function.
+       */
+      //size_type
+      //max_size() const;
+      using _Base_type::max_size;
+
+      /**
+       * @todo Document this function.
+       */
+      bool
+      empty() const
+      { return size() == 0; }
+      
+      // [7.10.3] element access
+      /**
+       * @brief Gets the length of the indicated submatch.
+       * @param sub indicates the submatch.
+       */
+      difference_type
+      length(size_type __sub = 0) const
+      { return _M_matched ? this->str(__sub).length() : 0; }
+
+      /**
+       * @todo Document this function.
+       */
+      difference_type
+      position(size_type __sub = 0) const
+      {
+	return _M_matched ? std::distance(this->prefix().first,
+					  (*this)[__sub].first) : 0;
+      }
+
+      /**
+       * @todo Document this function.
+       */
+      string_type
+      str(size_type __sub = 0) const
+      { return _M_matched ? (*this)[__sub].str() : string_type(); }
+      
+      /**
+       * @todo Document this function.
+       */
+      const_reference
+      operator[](size_type __n) const
+      { return _Base_type::operator[](__n); }
+
+      /**
+       * @todo Document this function.
+       */
+      const_reference
+      prefix() const
+      { return _M_prefix; }
+
+      /**
+       * @todo Document this function.
+       */
+      const_reference
+      suffix() const
+      { return _M_suffix; }
+
+      /**
+       * @todo Document this function.
+       */
+      const_iterator
+      begin() const
+      { return _Base_type::begin(); }
+      
+      /**
+       * @todo Document this function.
+       */
+      const_iterator
+      end() const
+      { return _Base_type::end(); }
+      
+      // [7.10.4] format
+      /**
+       * @todo Implement this function.
+       */
+      template<typename _Out_iter>
+        _Out_iter
+        format(_Out_iter __out, const string_type& __fmt,
+	       regex_constants::match_flag_type __flags
+	       = regex_constants::format_default) const
+        { return __out; }
+
+      /**
+       * @todo Implement this function.
+       */
+      string_type
+      format(const string_type& __fmt,
+	     regex_constants::match_flag_type __flags
+	     = regex_constants::format_default) const;
+
+      // [7.10.5] allocator
+      /**
+       * @todo Document this function.
+       */
+      //allocator_type
+      //get_allocator() const;
+      using _Base_type::get_allocator;
+      
+      // [7.10.6] swap
+      /**
+       * @todo Document this function.
+       */
+      void
+      swap(match_results& __that)
+      {
+	_Base_type::swap(__that);
+	std::swap(_M_matched, __that._M_matched);
+	std::swap(_M_prefix,  __that._M_prefix);
+	std::swap(_M_suffix,  __that._M_suffix);
+      }
+      
+    private:
+      bool       _M_matched;
+      value_type _M_prefix;
+      value_type _M_suffix;
+    };
+  
+  typedef match_results<const char*>             cmatch;
+  typedef match_results<string::const_iterator>  smatch;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  typedef match_results<const wchar_t*>          wcmatch;
+  typedef match_results<wstring::const_iterator> wsmatch;
+#endif
+
+  // match_results comparisons
+  /**
+   * @todo Implement this function.
+   */
+  template<typename _Bi_iter, typename _Allocator>
+    inline bool
+    operator==(const match_results<_Bi_iter, _Allocator>& __m1,
+	       const match_results<_Bi_iter, _Allocator>& __m2);
+
+  /**
+   * @todo Implement this function.
+   */
+  template<typename _Bi_iter, class _Allocator>
+    inline bool
+    operator!=(const match_results<_Bi_iter, _Allocator>& __m1,
+	       const match_results<_Bi_iter, _Allocator>& __m2);
+
+  // [7.10.6] match_results swap
+  /**
+   * @brief Swaps two match results.
+   * @param lhs A match result.
+   * @param rhs A match result.
+   *
+   * The contents of the two match_results objects are swapped.
+   */
+  template<typename _Bi_iter, typename _Allocator>
+    inline void
+    swap(match_results<_Bi_iter, _Allocator>& __lhs,
+	 match_results<_Bi_iter, _Allocator>& __rhs)
+    { return __lhs.swap(__rhs); }
+
+  // [7.11.2] Function template regex_match
+  /**
+   * @brief Determines if there is a match between the regular expression @p e
+   * and all of the character sequence [first, last).
+   *
+   * @param first Beginning of the character sequence to match.
+   * @param last  One-past-the-end of the character sequence to match.
+   * @param m     The match results.
+   * @param re    The regular expression.
+   * @param flags Controls how the regular expression is matched.
+   *
+   * @retval true  A match exists.
+   * @retval false Otherwise.
+   *
+   * @todo Implement this function.
+   */
+  template<typename _Bi_iter, typename _Allocator,
+	   typename _Ch_type, typename _Rx_traits>
+    bool
+    regex_match(_Bi_iter __first, _Bi_iter __last,
+		match_results<_Bi_iter, _Allocator>& __m,
+		const basic_regex<_Ch_type, _Rx_traits>& __re,
+		regex_constants::match_flag_type __flags
+		= regex_constants::match_default)
+    { return false; }
+
+  /**
+   * @brief Indicates if there is a match between the regular expression @p e
+   * and all of the character sequence [first, last).
+   *
+   * @param first Beginning of the character sequence to match.
+   * @param last  One-past-the-end of the character sequence to match.
+   * @param re    The regular expression.
+   * @param flags Controls how the regular expression is matched.
+   *
+   * @retval true  A match exists.
+   * @retval false Otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
+    bool
+    regex_match(_Bi_iter __first, _Bi_iter __last,
+		const basic_regex<_Ch_type, _Rx_traits>& __re,
+		regex_constants::match_flag_type __flags
+		= regex_constants::match_default)
+    { 
+      match_results<_Bi_iter> __what;
+      return regex_match(__first, __last, __what, __re, __flags);
+    }
+
+  /**
+   * @brief Determines if there is a match between the regular expression @p e
+   * and a C-style null-terminated string.
+   *
+   * @param s  The C-style null-terminated string to match.
+   * @param m  The match results.
+   * @param re The regular expression.
+   * @param f  Controls how the regular expression is matched.
+   *
+   * @retval true  A match exists.
+   * @retval false Otherwise.
+   */
+  template<typename _Ch_type, typename _Allocator, typename _Rx_traits>
+    inline bool
+    regex_match(const _Ch_type* __s,
+		match_results<const _Ch_type*, _Allocator>& __m,
+		const basic_regex<_Ch_type, _Rx_traits>& __re,
+		regex_constants::match_flag_type __f
+		= regex_constants::match_default)
+    { return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); }
+
+  /**
+   * @brief Determines if there is a match between the regular expression @p e
+   * and a string.
+   *
+   * @param s     The string to match.
+   * @param m     The match results.
+   * @param re    The regular expression.
+   * @param flags Controls how the regular expression is matched.
+   *
+   * @retval true  A match exists.
+   * @retval false Otherwise.
+   */
+  template<typename _Ch_traits, typename _Ch_alloc,
+	   typename _Allocator, typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
+		match_results<typename basic_string<_Ch_type, 
+		_Ch_traits, _Ch_alloc>::const_iterator, _Allocator>& __m,
+		const basic_regex<_Ch_type, _Rx_traits>& __re,
+		regex_constants::match_flag_type __flags
+		= regex_constants::match_default)
+    { return regex_match(__s.begin(), __s.end(), __m, __re, __flags); }
+
+  /**
+   * @brief Indicates if there is a match between the regular expression @p e
+   * and a C-style null-terminated string.
+   *
+   * @param s  The C-style null-terminated string to match.
+   * @param re The regular expression.
+   * @param f  Controls how the regular expression is matched.
+   *
+   * @retval true  A match exists.
+   * @retval false Otherwise.
+   */
+  template<typename _Ch_type, class _Rx_traits>
+    inline bool
+    regex_match(const _Ch_type* __s,
+		const basic_regex<_Ch_type, _Rx_traits>& __re,
+		regex_constants::match_flag_type __f
+		= regex_constants::match_default)
+    { return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); }
+
+  /**
+   * @brief Indicates if there is a match between the regular expression @p e
+   * and a string.
+   *
+   * @param s     [IN] The string to match.
+   * @param re    [IN] The regular expression.
+   * @param flags [IN] Controls how the regular expression is matched.
+   *
+   * @retval true  A match exists.
+   * @retval false Otherwise.
+   */
+  template<typename _Ch_traits, typename _Str_allocator,
+	   typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_match(const basic_string<_Ch_type, _Ch_traits, _Str_allocator>& __s,
+		const basic_regex<_Ch_type, _Rx_traits>& __re,
+		regex_constants::match_flag_type __flags
+		= regex_constants::match_default)
+    { return regex_match(__s.begin(), __s.end(), __re, __flags); }
+
+  // [7.11.3] Function template regex_search
+  /**
+   * Searches for a regular expression within a range.
+   * @param first [IN]  The start of the string to search.
+   * @param last  [IN]  One-past-the-end of the string to search.
+   * @param m     [OUT] The match results.
+   * @param re    [IN]  The regular expression to search for.
+   * @param flags [IN]  Search policy flags.
+   * @retval true  A match was found within the string.
+   * @retval false No match was found within the string, the content of %m is
+   *               undefined.
+   * @todo Implement this function.
+   */
+  template<typename _Bi_iter, typename _Allocator,
+	   typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_search(_Bi_iter __first, _Bi_iter __last,
+		 match_results<_Bi_iter, _Allocator>& __m,
+		 const basic_regex<_Ch_type, _Rx_traits>& __re,
+		 regex_constants::match_flag_type __flags
+		 = regex_constants::match_default)
+    { return false; }
+
+  /**
+   * Searches for a regular expression within a range.
+   * @param first [IN]  The start of the string to search.
+   * @param last  [IN]  One-past-the-end of the string to search.
+   * @param re    [IN]  The regular expression to search for.
+   * @param flags [IN]  Search policy flags.
+   * @retval true  A match was found within the string.
+   * @retval false No match was found within the string.
+   * @todo Document me.
+   */
+  template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_search(_Bi_iter __first, _Bi_iter __last,
+		 const basic_regex<_Ch_type, _Rx_traits>& __re,
+		 regex_constants::match_flag_type __flags
+		 = regex_constants::match_default)
+    {
+      match_results<_Bi_iter> __what;
+      return regex_search(__first, __last, __what, __re, __flags);
+    }
+
+  /**
+   * @brief Searches for a regular expression within a C-string.
+   * @param s [IN]  A C-string to search for the regex.
+   * @param m [OUT] The set of regex mnatches.
+   * @param e [IN]  The regex to search for in @p s.
+   * @param f [IN]  The search flags.
+   * @retval true  A match was found within the string.
+   * @retval false No match was found within the string, the content of %m is
+   *               undefined.
+   * @todo Document me.
+   */
+  template<typename _Ch_type, class _Allocator, class _Rx_traits>
+    inline bool
+    regex_search(const _Ch_type* __s,
+		 match_results<const _Ch_type*, _Allocator>& __m,
+		 const basic_regex<_Ch_type, _Rx_traits>& __e,
+		 regex_constants::match_flag_type __f
+		 = regex_constants::match_default)
+    { return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); }
+
+  /**
+   * @brief Searches for a regular expression within a C-string.
+   * @param s [IN]  The C-string to search.
+   * @param e [IN]  The regular expressioon to search for.
+   * @param f [IN]  Search policy flags.
+   * @retval true  A match was found within the string.
+   * @retval false No match was found within the string.
+   * @todo Document me.
+   */
+  template<typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_search(const _Ch_type* __s,
+		 const basic_regex<_Ch_type, _Rx_traits>& __e,
+		 regex_constants::match_flag_type __f
+		 = regex_constants::match_default)
+    { return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); }
+
+  /**
+   * @brief Searches for a regular expression within a string.
+   * @param s     [IN]  The string to search.
+   * @param e     [IN]  The regular expressioon to search for.
+   * @param flags [IN]  Search policy flags.
+   * @retval true  A match was found within the string.
+   * @retval false No match was found within the string.
+   * @todo Document me.
+   */
+  template<typename _Ch_traits, typename _String_allocator,
+	   typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_search(const basic_string<_Ch_type, _Ch_traits,
+		 _String_allocator>& __s,
+		 const basic_regex<_Ch_type, _Rx_traits>& __e,
+		 regex_constants::match_flag_type __flags
+		 = regex_constants::match_default)
+    { return regex_search(__s.begin(), __s.end(), __e, __flags); }
+
+  /**
+   * @brief Searches for a regular expression within a string.
+   * @param s [IN]  A C++ string to search for the regex.
+   * @param m [OUT] The set of regex mnatches.
+   * @param e [IN]  The regex to search for in @p s.
+   * @param f [IN]  The search flags.
+   * @retval true  A match was found within the string.
+   * @retval false No match was found within the string, the content of %m is
+   *               undefined.
+   */
+  template<typename _Ch_traits, typename _Ch_alloc,
+	   typename _Allocator, typename _Ch_type,
+	   typename _Rx_traits>
+    inline bool
+    regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
+		 match_results<typename basic_string<_Ch_type,
+		 _Ch_traits, _Ch_alloc>::const_iterator, _Allocator>& __m,
+		 const basic_regex<_Ch_type, _Rx_traits>& __e,
+		 regex_constants::match_flag_type __f
+		 = regex_constants::match_default)
+    { return regex_search(__s.begin(), __s.end(), __m, __e, __f); }
+
+  // [7.11.4] Function template regex_replace
+  /**
+   * @todo Implement this function.
+   * @todo Document this function.
+   */
+  template<typename _Out_iter, typename _Bi_iter,
+	   typename _Rx_traits, typename _Ch_type>
+    inline _Out_iter
+    regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
+		  const basic_regex<_Ch_type, _Rx_traits>& __e,
+		  const basic_string<_Ch_type>& __fmt,
+		  regex_constants::match_flag_type __flags
+		  = regex_constants::match_default)
+    { return __out; }
+
+  /**
+   * @todo Document me.
+   */
+  template<typename _Rx_traits, typename _Ch_type>
+    inline basic_string<_Ch_type>
+    regex_replace(const basic_string<_Ch_type>& __s,
+		  const basic_regex<_Ch_type, _Rx_traits>& __e,
+		  const basic_string<_Ch_type>& __fmt,
+		  regex_constants::match_flag_type __flags
+		  = regex_constants::match_default)
+    {
+      std::string __result;
+      regex_replace(std::back_inserter(__result),
+		    __s.begin(), __s.end(), __e, __fmt, __flags);
+      return __result;
+    }
+
+  // [7.12.1] Class template regex_iterator
+  /**
+   * An iterator adaptor that will provide repeated calls of regex_search over 
+   * a range until no more matches remain.
+   */
+  template<typename _Bi_iter,
+	   typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
+	   typename _Rx_traits = regex_traits<_Ch_type> >
+    class regex_iterator
+    {
+    public:
+      typedef basic_regex<_Ch_type, _Rx_traits>  regex_type;
+      typedef match_results<_Bi_iter>            value_type;
+      typedef std::ptrdiff_t                     difference_type;
+      typedef const value_type*                  pointer;
+      typedef const value_type&                  reference;
+      typedef std::forward_iterator_tag          iterator_category;
+
+    public:
+      /**
+       * @brief Provides a singular iterator, useful for indicating
+       * one-past-the-end of a range.
+       * @todo Implement this function.
+       * @todo Document this function.
+       */
+      regex_iterator();
+      
+      /**
+       * Constructs a %regex_iterator...
+       * @param a  [IN] The start of a text range to search.
+       * @param b  [IN] One-past-the-end of the text range to search.
+       * @param re [IN] The regular expression to match.
+       * @param m  [IN] Policy flags for match rules.
+       * @todo Implement this function.
+       * @todo Document this function.
+       */
+      regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
+		     regex_constants::match_flag_type __m
+		     = regex_constants::match_default);
+
+      /**
+       * Copy constructs a %regex_iterator.
+       * @todo Implement this function.
+       * @todo Document this function.
+       */
+      regex_iterator(const regex_iterator& __rhs);
+      
+      /**
+       * @todo Implement this function.
+       * @todo Document this function.
+       */
+      regex_iterator&
+      operator=(const regex_iterator& __rhs);
+      
+      /**
+       * @todo Implement this function.
+       * @todo Document this function.
+       */
+      bool
+      operator==(const regex_iterator& __rhs);
+      
+      /**
+       * @todo Implement this function.
+       * @todo Document this function.
+       */
+      bool
+      operator!=(const regex_iterator& __rhs);
+      
+      /**
+       * @todo Implement this function.
+       * @todo Document this function.
+       */
+      const value_type&
+      operator*();
+      
+      /**
+       * @todo Implement this function.
+       * @todo Document this function.
+       */
+      const value_type*
+      operator->();
+      
+      /**
+       * @todo Implement this function.
+       * @todo Document this function.
+       */
+      regex_iterator&
+      operator++();
+      
+      /**
+       * @todo Implement this function.
+       * @todo Document this function.
+       */
+      regex_iterator
+      operator++(int);
+      
+    private:
+      // these members are shown for exposition only:
+      _Bi_iter                         begin;
+      _Bi_iter                         end;
+      const regex_type*                pregex;
+      regex_constants::match_flag_type flags;
+      match_results<_Bi_iter>          match;
+    };
+  
+  typedef regex_iterator<const char*>             cregex_iterator;
+  typedef regex_iterator<string::const_iterator>  sregex_iterator;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  typedef regex_iterator<const wchar_t*>          wcregex_iterator;
+  typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
+#endif
+
+  // [7.12.2] Class template regex_token_iterator
+  /**
+   * Iterates over submatches in a range (or "splits" a text string).
+   *
+   * The purpose of this iterator is to enumerate all, or all specified,
+   * matches of a regular expression within a text range.  The dereferenced
+   * value of an iterator of this class is a std::tr1::sub_match object.
+   */
+  template<typename _Bi_iter,
+	   typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
+	   typename _Rx_traits = regex_traits<_Ch_type> >
+    class regex_token_iterator
+    {
+    public:
+      typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
+      typedef sub_match<_Bi_iter>               value_type;
+      typedef std::ptrdiff_t                    difference_type;
+      typedef const value_type*                 pointer;
+      typedef const value_type&                 reference;
+      typedef std::forward_iterator_tag         iterator_category;
+      
+    public:
+      /**
+       * @brief Default constructs a %regex_token_iterator.
+       * @todo Implement this function.
+       * 
+       * A default-constructed %regex_token_iterator is a singular iterator
+       * that will compare equal to the one-past-the-end value for any
+       * iterator of the same type.
+       */
+      regex_token_iterator();
+      
+      /**
+       * Constrcts a %regex_token_iterator...
+       * @param a          [IN] The start of the text to search.
+       * @param b          [IN] One-past-the-eend of the text to search.
+       * @param re         [IN] The regular expression to search for.
+       * @param submatch   [IN] Which submatch to return.  There are some
+       *                        special values for thsi parameter:
+       *                        - -1 each enumerated subexpression does NOT
+       *                          match the regular expression (aka field
+       *                          splitting)
+       *                        - 0 the entire string matching the
+       *                          subexpression is returned for each match
+       *                          within the text.
+       *                        - >0 enumerates only the indicated
+       *                          subexpression from a match within the text.
+       * @param m          [IN] Policy flags for match rules.
+       *
+       * @todo Implement this function.
+       * @todo Document this function.
+       */
+      regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
+			   int __submatch = 0,
+			   regex_constants::match_flag_type __m
+			   = regex_constants::match_default);
+
+      /**
+       * Constrcts a %regex_token_iterator...
+       * @param a          [IN] The start of the text to search.
+       * @param b          [IN] One-past-the-eend of the text to search.
+       * @param re         [IN] The regular expression to search for.
+       * @param submatches [IN] A list of subexpressions to return for each
+       *                        regular expression match within the text.
+       * @param m          [IN] Policy flags for match rules.
+       *
+       * @todo Implement this function.
+       * @todo Document this function.
+       */
+      regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
+			   const regex_type& __re,
+			   const std::vector<int>& __submatches,
+			   regex_constants::match_flag_type __m
+			     = regex_constants::match_default);
+
+      /**
+       * Constrcts a %regex_token_iterator...
+       * @param a          [IN] The start of the text to search.
+       * @param b          [IN] One-past-the-eend of the text to search.
+       * @param re         [IN] The regular expression to search for.
+       * @param submatches [IN] A list of subexpressions to return for each
+       *                        regular expression match within the text.
+       * @param m          [IN] Policy flags for match rules.
+       
+       * @todo Implement this function.
+       * @todo Document this function.
+       */
+      template<std::size_t _Nm>
+        regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
+			     const regex_type& __re,
+			     const int (&__submatches)[_Nm],
+			     regex_constants::match_flag_type __m
+			     = regex_constants::match_default);
+
+      /**
+       * @brief Copy constructs a %regex_token_iterator.
+       * @param rhs [IN] A %regex_token_iterator to copy.
+       * @todo Implement this function.
+       */
+      regex_token_iterator(const regex_token_iterator& __rhs);
+      
+      /**
+       * @brief Assigns a %regex_token_iterator to another.
+       * @param rhs [IN] A %regex_token_iterator to copy.
+       * @todo Implement this function.
+       */
+      regex_token_iterator&
+      operator=(const regex_token_iterator& __rhs);
+      
+      /**
+       * @brief Compares a %regex_token_iterator to another for equality.
+       * @todo Implement this function.
+       */
+      bool
+      operator==(const regex_token_iterator& __rhs);
+      
+      /**
+       * @brief Compares a %regex_token_iterator to another for inequality.
+       * @todo Implement this function.
+       */
+      bool
+      operator!=(const regex_token_iterator& __rhs);
+      
+      /**
+       * @brief Dereferences a %regex_token_iterator.
+       * @todo Implement this function.
+       */
+      const value_type&
+      operator*();
+      
+      /**
+       * @brief Selects a %regex_token_iterator member.
+       * @todo Implement this function.
+       */
+      const value_type*
+      operator->();
+      
+      /**
+       * @brief Increments a %regex_token_iterator.
+       * @todo Implement this function.
+       */
+      regex_token_iterator&
+      operator++();
+      
+      /**
+       * @brief Postincrements a %regex_token_iterator.
+       * @todo Implement this function.
+       */
+      regex_token_iterator
+      operator++(int);
+      
+    private: // data members for exposition only:
+      typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> position_iterator;
+
+      position_iterator __position;
+      const value_type* __result;
+      value_type        __suffix;
+      std::size_t       __n;
+      std::vector<int>  __subs;
+    };
+
+  typedef regex_token_iterator<const char*>             cregex_token_iterator;
+  typedef regex_token_iterator<string::const_iterator>  sregex_token_iterator;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  typedef regex_token_iterator<const wchar_t*>          wcregex_token_iterator;
+  typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
+#endif
+  
+  /** @} */ // group tr1_regex
+  
+_GLIBCXX_END_NAMESPACE_TR1
+}
diff --git a/libstdc++-v3/include/tr1_impl/tuple b/libstdc++-v3/include/tr1_impl/tuple
new file mode 100644
index 0000000..52017d6
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/tuple
@@ -0,0 +1,430 @@
+// class template tuple -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/tuple
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+*/
+
+// Chris Jefferson <chris@bubblescope.net>
+// Variadic Templates support by Douglas Gregor <doug.gregor@gmail.com>
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+  template<typename _Tp>
+    class reference_wrapper;
+
+  // Adds a const reference to a non-reference type.
+  template<typename _Tp>
+    struct __add_c_ref
+    { typedef const _Tp& type; };
+
+  template<typename _Tp>
+    struct __add_c_ref<_Tp&>
+    { typedef _Tp& type; };
+
+  // Adds a reference to a non-reference type.
+  template<typename _Tp>
+    struct __add_ref
+    { typedef _Tp& type; };
+
+  template<typename _Tp>
+    struct __add_ref<_Tp&>
+    { typedef _Tp& type; };
+
+  /**
+   * @if maint
+   * Contains the actual implementation of the @c tuple template, stored
+   * as a recursive inheritance hierarchy from the first element (most
+   * derived class) to the last (least derived class). The @c Idx
+   * parameter gives the 0-based index of the element stored at this
+   * point in the hierarchy; we use it to implement a constant-time
+   * get() operation.
+   * @endif
+   */
+  template<int _Idx, typename... _Elements>
+    struct _Tuple_impl; 
+
+  /**
+   * @if maint
+   * Zero-element tuple implementation. This is the basis case for the 
+   * inheritance recursion.
+   * @endif maint
+   */
+  template<int _Idx>
+    struct _Tuple_impl<_Idx> { };
+
+  /**
+   * @if maint
+   * Recursive tuple implementation. Here we store the @c Head element
+   * and derive from a @c Tuple_impl containing the remaining elements
+   * (which contains the @c Tail).
+   * @endif
+   */
+  template<int _Idx, typename _Head, typename... _Tail>
+    struct _Tuple_impl<_Idx, _Head, _Tail...>
+    : public _Tuple_impl<_Idx + 1, _Tail...>
+    {
+      typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
+      
+      _Head _M_head;
+      
+      _Inherited&       _M_tail()       { return *this; }
+      const _Inherited& _M_tail() const { return *this; }
+      
+      _Tuple_impl() : _Inherited(), _M_head() { }
+      
+      explicit 
+      _Tuple_impl(typename __add_c_ref<_Head>::type __head,
+		  typename __add_c_ref<_Tail>::type... __tail)
+      : _Inherited(__tail...), _M_head(__head) { }
+
+      template<typename... _UElements>
+      _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
+      : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
+
+      _Tuple_impl(const _Tuple_impl& __in)
+      : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
+     
+      template<typename... _UElements>
+        _Tuple_impl&
+        operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
+        {
+	  _M_head = __in._M_head;
+	  _M_tail() = __in._M_tail();
+	  return *this;
+	}
+
+      _Tuple_impl&
+      operator=(const _Tuple_impl& __in)
+      {
+	_M_head = __in._M_head;
+	_M_tail() = __in._M_tail();
+	return *this;
+      }
+    };
+
+  template<typename... _Elements> 
+    class tuple : public _Tuple_impl<0, _Elements...>
+    {
+      typedef _Tuple_impl<0, _Elements...> _Inherited;
+
+    public:
+      tuple() : _Inherited() { }
+
+      explicit
+      tuple(typename __add_c_ref<_Elements>::type... __elements)
+      : _Inherited(__elements...) { }
+
+      template<typename... _UElements>
+        tuple(const tuple<_UElements...>& __in)
+	: _Inherited(__in) { }
+
+      tuple(const tuple& __in)
+      : _Inherited(__in) { }
+
+      template<typename... _UElements>
+        tuple&
+        operator=(const tuple<_UElements...>& __in)
+        {
+	  static_cast<_Inherited&>(*this) = __in;
+	  return *this;
+	}
+
+      tuple&
+      operator=(const tuple& __in)
+      {
+	static_cast<_Inherited&>(*this) = __in;
+	return *this;
+      }
+    };
+
+  template<> class tuple<> { };
+
+  // 2-element tuple, with construction and assignment from a pair.
+  template<typename _T1, typename _T2>
+    class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
+    {
+      typedef _Tuple_impl<0, _T1, _T2> _Inherited;
+
+    public:
+      tuple() : _Inherited() { }
+
+      explicit
+      tuple(typename __add_c_ref<_T1>::type __a1,
+	    typename __add_c_ref<_T2>::type __a2)
+      : _Inherited(__a1, __a2) { }
+
+      template<typename _U1, typename _U2>
+        tuple(const tuple<_U1, _U2>& __in)
+	: _Inherited(__in) { }
+
+      tuple(const tuple& __in)
+      : _Inherited(__in) { }
+
+      template<typename _U1, typename _U2>
+        tuple(const pair<_U1, _U2>& __in)
+	: _Inherited(_Tuple_impl<0, 
+		     typename __add_c_ref<_U1>::type,
+		     typename __add_c_ref<_U2>::type>(__in.first, 
+						      __in.second))
+        { }
+  
+      template<typename _U1, typename _U2>
+        tuple&
+        operator=(const tuple<_U1, _U2>& __in)
+        {
+	  static_cast<_Inherited&>(*this) = __in;
+	  return *this;
+	}
+
+      tuple&
+      operator=(const tuple& __in)
+      {
+	static_cast<_Inherited&>(*this) = __in;
+	return *this;
+      }
+
+      template<typename _U1, typename _U2>
+        tuple&
+        operator=(const pair<_U1, _U2>& __in)
+        {
+	  this->_M_head = __in.first;
+	  this->_M_tail()._M_head = __in.second;
+	  return *this;
+	}
+    };
+
+  
+  /// Gives the type of the ith element of a given tuple type.
+  template<int __i, typename _Tp>
+    struct tuple_element;
+
+  /**
+   * @if maint
+   * Recursive case for tuple_element: strip off the first element in
+   * the tuple and retrieve the (i-1)th element of the remaining tuple.
+   * @endif
+   */
+  template<int __i, typename _Head, typename... _Tail>
+    struct tuple_element<__i, tuple<_Head, _Tail...> >
+    : tuple_element<__i - 1, tuple<_Tail...> > { };
+
+  /**
+   * @if maint
+   * Basis case for tuple_element: The first element is the one we're seeking.
+   * @endif
+   */
+  template<typename _Head, typename... _Tail>
+    struct tuple_element<0, tuple<_Head, _Tail...> >
+    {
+      typedef _Head type;
+    };
+
+  /// Finds the size of a given tuple type.
+  template<typename _Tp>
+    struct tuple_size;
+
+  /// @brief class tuple_size
+  template<typename... _Elements>
+    struct tuple_size<tuple<_Elements...> >
+    {
+      static const int value = sizeof...(_Elements);
+    };
+
+  template<typename... _Elements>
+    const int tuple_size<tuple<_Elements...> >::value;
+
+  template<int __i, typename _Head, typename... _Tail>
+    inline typename __add_ref<_Head>::type
+    __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t)
+    {
+      return __t._M_head;
+    }
+
+  template<int __i, typename _Head, typename... _Tail>
+    inline typename __add_c_ref<_Head>::type
+    __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t)
+    {
+      return __t._M_head;
+    }
+
+  // Return a reference (const reference) to the ith element of a tuple.
+  // Any const or non-const ref elements are returned with their original type.
+  template<int __i, typename... _Elements>
+    inline typename __add_ref<
+                      typename tuple_element<__i, tuple<_Elements...> >::type
+                    >::type
+    get(tuple<_Elements...>& __t)
+    { 
+      return __get_helper<__i>(__t); 
+    }
+
+  template<int __i, typename... _Elements>
+    inline typename __add_c_ref<
+                      typename tuple_element<__i, tuple<_Elements...> >::type
+                    >::type
+    get(const tuple<_Elements...>& __t)
+    {
+      return __get_helper<__i>(__t);
+    }
+
+  // This class helps construct the various comparison operations on tuples
+  template<int __check_equal_size, int __i, int __j,
+	   typename _Tp, typename _Up>
+    struct __tuple_compare;
+
+  template<int __i, int __j, typename _Tp, typename _Up>
+    struct __tuple_compare<0, __i, __j, _Tp, _Up>
+    {
+      static bool __eq(const _Tp& __t, const _Up& __u)
+      {
+	return (get<__i>(__t) == get<__i>(__u) &&
+		__tuple_compare<0, __i+1, __j, _Tp, _Up>::__eq(__t, __u));
+      }
+     
+      static bool __less(const _Tp& __t, const _Up& __u)
+      {
+	return ((get<__i>(__t) < get<__i>(__u))
+		|| !(get<__i>(__u) < get<__i>(__t)) &&
+		__tuple_compare<0, __i+1, __j, _Tp, _Up>::__less(__t, __u));
+      }
+    };
+
+  template<int __i, typename _Tp, typename _Up>
+    struct __tuple_compare<0, __i, __i, _Tp, _Up>
+    {
+      static bool __eq(const _Tp&, const _Up&)
+      { return true; }
+     
+      static bool __less(const _Tp&, const _Up&)
+      { return false; }
+    };
+
+  template<typename... _TElements, typename... _UElements>
+    bool
+    operator==(const tuple<_TElements...>& __t,
+	       const tuple<_UElements...>& __u)
+    {
+      typedef tuple<_TElements...> _Tp;
+      typedef tuple<_UElements...> _Up;
+      return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Tp>::value,
+	      0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u));
+    }
+
+  template<typename... _TElements, typename... _UElements>
+    bool
+    operator<(const tuple<_TElements...>& __t,
+	      const tuple<_UElements...>& __u)
+    {
+      typedef tuple<_TElements...> _Tp;
+      typedef tuple<_UElements...> _Up;
+      return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Tp>::value,
+	      0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u));
+    }
+
+  template<typename... _TElements, typename... _UElements>
+    bool
+    operator!=(const tuple<_TElements...>& __t,
+	       const tuple<_UElements...>& __u)
+    { return !(__t == __u); }
+
+  template<typename... _TElements, typename... _UElements>
+    bool
+    operator>(const tuple<_TElements...>& __t,
+	      const tuple<_UElements...>& __u)
+    { return __u < __t; }
+
+  template<typename... _TElements, typename... _UElements>
+    bool
+    operator<=(const tuple<_TElements...>& __t,
+	       const tuple<_UElements...>& __u)
+    { return !(__u < __t); }
+
+  template<typename... _TElements, typename... _UElements>
+    bool
+    operator>=(const tuple<_TElements...>& __t,
+	       const tuple<_UElements...>& __u)
+    { return !(__t < __u); }
+
+  // Helper which adds a reference to a type when given a reference_wrapper
+  template<typename _Tp>
+    struct __strip_reference_wrapper
+    {
+      typedef _Tp __type;
+    };
+
+  template<typename _Tp>
+    struct __strip_reference_wrapper<reference_wrapper<_Tp> >
+    {
+      typedef _Tp& __type;
+    };
+
+  template<typename _Tp>
+    struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
+    {
+      typedef _Tp& __type;
+    };
+
+  template<typename... _Elements>
+    inline tuple<typename __strip_reference_wrapper<_Elements>::__type...>
+    make_tuple(_Elements... __args)
+    {
+      typedef tuple<typename __strip_reference_wrapper<_Elements>::__type...>
+        __result_type;
+      return __result_type(__args...);
+    }
+
+  template<typename... _Elements>
+    inline tuple<_Elements&...>
+    tie(_Elements&... __args)
+    {
+      return tuple<_Elements&...>(__args...);
+    }
+
+  // A class (and instance) which can be used in 'tie' when an element
+  // of a tuple is not required
+  struct _Swallow_assign
+  {
+    template<class _Tp>
+      _Swallow_assign&
+      operator=(const _Tp&)
+      { return *this; }
+  };
+
+  // TODO: Put this in some kind of shared file.
+  namespace
+  {
+    _Swallow_assign ignore;
+  }; // anonymous namespace
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
diff --git a/libstdc++-v3/include/tr1_impl/type_traits b/libstdc++-v3/include/tr1_impl/type_traits
new file mode 100644
index 0000000..9fa77ca
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/type_traits
@@ -0,0 +1,489 @@
+// TR1 type_traits -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/type_traits
+*  This is an internal header file, included by other library headers.
+*  You should not attempt to use it directly.
+*/
+
+#include <tr1_impl/type_traitsfwd.h>
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+  // For use in __is_convertible_simple.
+  struct __sfinae_types
+  {
+    typedef char __one;
+    typedef struct { char __arr[2]; } __two;
+  };
+
+#define _DEFINE_SPEC_BODY(_Value)                                    \
+    : public integral_constant<bool, _Value> { };
+
+#define _DEFINE_SPEC_0_HELPER(_Spec, _Value)                         \
+  template<>                                                         \
+    struct _Spec                                                     \
+    _DEFINE_SPEC_BODY(_Value)
+
+#define _DEFINE_SPEC_1_HELPER(_Spec, _Value)                         \
+  template<typename _Tp>                                             \
+    struct _Spec                                                     \
+    _DEFINE_SPEC_BODY(_Value)
+      
+#define _DEFINE_SPEC_2_HELPER(_Spec, _Value)                         \
+  template<typename _Tp, typename _Cp>                               \
+    struct _Spec                                                     \
+    _DEFINE_SPEC_BODY(_Value)
+
+#define _DEFINE_SPEC(_Order, _Trait, _Type, _Value)                  \
+  _DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type>, _Value)              \
+  _DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type const>, _Value)        \
+  _DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type volatile>, _Value)     \
+  _DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type const volatile>, _Value)
+
+  /// @brief  helper classes [4.3].
+  template<typename _Tp, _Tp __v>
+    struct integral_constant
+    {
+      static const _Tp                      value = __v;
+      typedef _Tp                           value_type;
+      typedef integral_constant<_Tp, __v>   type;
+    };
+  typedef integral_constant<bool, true>     true_type;
+  typedef integral_constant<bool, false>    false_type;
+
+  template<typename _Tp, _Tp __v>
+    const _Tp integral_constant<_Tp, __v>::value;
+
+  /// @brief  primary type categories [4.5.1].
+  template<typename>
+    struct is_void
+    : public false_type { };
+  _DEFINE_SPEC(0, is_void, void, true)
+
+  template<typename>
+    struct is_integral
+    : public false_type { };
+  _DEFINE_SPEC(0, is_integral, bool, true)
+  _DEFINE_SPEC(0, is_integral, char, true)
+  _DEFINE_SPEC(0, is_integral, signed char, true)
+  _DEFINE_SPEC(0, is_integral, unsigned char, true)
+#ifdef _GLIBCXX_USE_WCHAR_T
+  _DEFINE_SPEC(0, is_integral, wchar_t, true)
+#endif
+  _DEFINE_SPEC(0, is_integral, short, true)
+  _DEFINE_SPEC(0, is_integral, unsigned short, true)
+  _DEFINE_SPEC(0, is_integral, int, true)
+  _DEFINE_SPEC(0, is_integral, unsigned int, true)
+  _DEFINE_SPEC(0, is_integral, long, true)
+  _DEFINE_SPEC(0, is_integral, unsigned long, true)
+  _DEFINE_SPEC(0, is_integral, long long, true)
+  _DEFINE_SPEC(0, is_integral, unsigned long long, true)
+
+  template<typename>
+    struct is_floating_point
+    : public false_type { };
+  _DEFINE_SPEC(0, is_floating_point, float, true)
+  _DEFINE_SPEC(0, is_floating_point, double, true)
+  _DEFINE_SPEC(0, is_floating_point, long double, true)
+
+  template<typename>
+    struct is_array
+    : public false_type { };
+
+  template<typename _Tp, std::size_t _Size>
+    struct is_array<_Tp[_Size]>
+    : public true_type { };
+
+  template<typename _Tp>
+    struct is_array<_Tp[]>
+    : public true_type { };
+
+  template<typename>
+    struct is_pointer
+    : public false_type { };
+  _DEFINE_SPEC(1, is_pointer, _Tp*, true)
+ 
+  template<typename>
+    struct is_reference
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_reference<_Tp&>
+    : public true_type { };
+
+  template<typename>
+    struct is_member_object_pointer
+    : public false_type { };
+  _DEFINE_SPEC(2, is_member_object_pointer, _Tp _Cp::*,
+	       !is_function<_Tp>::value)
+
+  template<typename>
+    struct is_member_function_pointer
+    : public false_type { };
+  _DEFINE_SPEC(2, is_member_function_pointer, _Tp _Cp::*,
+	       is_function<_Tp>::value)
+
+  template<typename _Tp>
+    struct is_enum
+    : public integral_constant<bool, __is_enum(_Tp)>
+    { };
+
+  template<typename _Tp>
+    struct is_union
+    : public integral_constant<bool, __is_union(_Tp)>
+    { };
+
+  template<typename _Tp>
+    struct is_class
+    : public integral_constant<bool, __is_class(_Tp)>
+    { };
+
+  template<typename>
+    struct __is_function_helper
+    : public false_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct __is_function_helper<_Res(_ArgTypes...)>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct __is_function_helper<_Res(_ArgTypes......)>
+    : public true_type { };
+
+  template<typename _Tp>
+    struct is_function
+    : public integral_constant<bool, (__is_function_helper<typename
+				      remove_cv<_Tp>::type>::value)>
+    { };
+
+  /// @brief  composite type traits [4.5.2].
+  template<typename _Tp>
+    struct is_arithmetic
+    : public integral_constant<bool, (is_integral<_Tp>::value
+				      || is_floating_point<_Tp>::value)>
+    { };
+
+  template<typename _Tp>
+    struct is_fundamental
+    : public integral_constant<bool, (is_arithmetic<_Tp>::value
+				      || is_void<_Tp>::value)>
+    { };
+
+  template<typename _Tp>
+    struct is_object
+    : public integral_constant<bool, !(is_function<_Tp>::value
+				       || is_reference<_Tp>::value
+				       || is_void<_Tp>::value)>
+    { };
+
+  template<typename _Tp>
+    struct is_scalar
+    : public integral_constant<bool, (is_arithmetic<_Tp>::value
+				      || is_enum<_Tp>::value
+				      || is_pointer<_Tp>::value
+				      || is_member_pointer<_Tp>::value)>
+    { };
+
+  template<typename _Tp>
+    struct is_compound
+    : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
+
+  template<typename _Tp>
+    struct is_member_pointer
+    : public integral_constant<bool,
+			       (is_member_object_pointer<_Tp>::value
+				|| is_member_function_pointer<_Tp>::value)>
+    { };
+
+  /// @brief  type properties [4.5.3].
+  template<typename>
+    struct is_const
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_const<_Tp const>
+    : public true_type { };
+  
+  template<typename>
+    struct is_volatile
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_volatile<_Tp volatile>
+    : public true_type { };
+
+  template<typename _Tp>
+    struct is_empty
+    : public integral_constant<bool, __is_empty(_Tp)>
+    { };
+
+  template<typename _Tp>
+    struct is_polymorphic
+    : public integral_constant<bool, __is_polymorphic(_Tp)>
+    { };
+
+  template<typename _Tp>
+    struct is_abstract
+    : public integral_constant<bool, __is_abstract(_Tp)>
+    { };
+
+  template<typename _Tp>
+    struct has_virtual_destructor
+    : public integral_constant<bool, __has_virtual_destructor(_Tp)>
+    { };
+
+  template<typename _Tp>
+    struct alignment_of
+    : public integral_constant<std::size_t, __alignof__(_Tp)> { };
+  
+  template<typename>
+    struct rank
+    : public integral_constant<std::size_t, 0> { };
+   
+  template<typename _Tp, std::size_t _Size>
+    struct rank<_Tp[_Size]>
+    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
+
+  template<typename _Tp>
+    struct rank<_Tp[]>
+    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
+   
+  template<typename, unsigned>
+    struct extent
+    : public integral_constant<std::size_t, 0> { };
+  
+  template<typename _Tp, unsigned _Uint, std::size_t _Size>
+    struct extent<_Tp[_Size], _Uint>
+    : public integral_constant<std::size_t,
+			       _Uint == 0 ? _Size : extent<_Tp,
+							   _Uint - 1>::value>
+    { };
+
+  template<typename _Tp, unsigned _Uint>
+    struct extent<_Tp[], _Uint>
+    : public integral_constant<std::size_t,
+			       _Uint == 0 ? 0 : extent<_Tp,
+						       _Uint - 1>::value>
+    { };
+  
+  /// @brief  relationships between types [4.6].
+  template<typename, typename>
+    struct is_same
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_same<_Tp, _Tp>
+    : public true_type { };
+
+  /// @brief  const-volatile modifications [4.7.1].
+  template<typename _Tp>
+    struct remove_const
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct remove_const<_Tp const>
+    { typedef _Tp     type; };
+  
+  template<typename _Tp>
+    struct remove_volatile
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct remove_volatile<_Tp volatile>
+    { typedef _Tp     type; };
+  
+  template<typename _Tp>
+    struct remove_cv
+    {
+      typedef typename
+      remove_const<typename remove_volatile<_Tp>::type>::type     type;
+    };
+  
+  template<typename _Tp>
+    struct add_const
+    { typedef _Tp const     type; };
+   
+  template<typename _Tp>
+    struct add_volatile
+    { typedef _Tp volatile     type; };
+  
+  template<typename _Tp>
+    struct add_cv
+    {
+      typedef typename
+      add_const<typename add_volatile<_Tp>::type>::type     type;
+    };
+
+  /// @brief  reference modifications [4.7.2].
+  template<typename _Tp>
+    struct remove_reference
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct remove_reference<_Tp&>
+    { typedef _Tp     type; };
+
+  // NB: Careful with reference to void.
+  template<typename _Tp, bool = (is_void<_Tp>::value
+				 || is_reference<_Tp>::value)>
+    struct __add_reference_helper
+    { typedef _Tp&    type; };
+
+  template<typename _Tp>
+    struct __add_reference_helper<_Tp, true>
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct add_reference
+    : public __add_reference_helper<_Tp>
+    { };
+
+  /// @brief  array modifications [4.7.3].
+  template<typename _Tp>
+    struct remove_extent
+    { typedef _Tp     type; };
+
+  template<typename _Tp, std::size_t _Size>
+    struct remove_extent<_Tp[_Size]>
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct remove_extent<_Tp[]>
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct remove_all_extents
+    { typedef _Tp     type; };
+
+  template<typename _Tp, std::size_t _Size>
+    struct remove_all_extents<_Tp[_Size]>
+    { typedef typename remove_all_extents<_Tp>::type     type; };
+
+  template<typename _Tp>
+    struct remove_all_extents<_Tp[]>
+    { typedef typename remove_all_extents<_Tp>::type     type; };
+
+  /// @brief  pointer modifications [4.7.4].
+#undef _DEFINE_SPEC_BODY
+#define _DEFINE_SPEC_BODY(_Value)      \
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct remove_pointer
+    { typedef _Tp     type; };
+  _DEFINE_SPEC(1, remove_pointer, _Tp*, false)
+  
+  template<typename _Tp>
+    struct add_pointer
+    { typedef typename remove_reference<_Tp>::type*     type; };
+
+  /// @brief  other transformations [4.8].
+  
+  // Due to c++/19163 and c++/17743, for the time being we cannot use
+  // the correct, neat implementation :-(
+  // 
+  // template<std::size_t _Len, std::size_t _Align>
+  //   struct aligned_storage
+  //   { typedef char type[_Len] __attribute__((__aligned__(_Align))); }
+  //
+  // Temporary workaround, useful for Align up to 32:
+  template<std::size_t, std::size_t>
+    struct aligned_storage { };
+
+  template<std::size_t _Len>
+    struct aligned_storage<_Len, 1>
+    {
+      union type
+      {
+	unsigned char __data[_Len];
+	char __align __attribute__((__aligned__(1)));
+      };
+    };
+
+  template<std::size_t _Len>
+    struct aligned_storage<_Len, 2>
+    {
+      union type
+      {
+	unsigned char __data[_Len];
+	char __align __attribute__((__aligned__(2)));
+      };
+    };
+
+  template<std::size_t _Len>
+    struct aligned_storage<_Len, 4>
+    {
+      union type
+      {
+	unsigned char __data[_Len];
+	char __align __attribute__((__aligned__(4)));
+      };
+    };
+
+  template<std::size_t _Len>
+    struct aligned_storage<_Len, 8>
+    {
+      union type
+      {
+	unsigned char __data[_Len];
+	char __align __attribute__((__aligned__(8)));
+      };
+    };
+
+  template<std::size_t _Len>
+    struct aligned_storage<_Len, 16>
+    {
+      union type
+      {
+	unsigned char __data[_Len];
+	char __align __attribute__((__aligned__(16)));
+      };
+    };
+  
+  template<std::size_t _Len>
+    struct aligned_storage<_Len, 32>
+    {
+      union type
+      {
+	unsigned char __data[_Len];
+	char __align __attribute__((__aligned__(32)));
+      };
+    };
+
+#undef _DEFINE_SPEC_0_HELPER
+#undef _DEFINE_SPEC_1_HELPER
+#undef _DEFINE_SPEC_2_HELPER
+#undef _DEFINE_SPEC
+#undef _DEFINE_SPEC_BODY
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
diff --git a/libstdc++-v3/include/tr1/type_traitsfwd.h b/libstdc++-v3/include/tr1_impl/type_traitsfwd.h
index 9cf2de6..1565df0 100644
--- a/libstdc++-v3/include/tr1/type_traitsfwd.h
+++ b/libstdc++-v3/include/tr1_impl/type_traitsfwd.h
@@ -1,6 +1,6 @@
-// TR1 type_traits -*- C++ -*-
+// TR1 type_traitsfwd.h -*- C++ -*-
 
-// Copyright (C) 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -27,20 +27,14 @@
 // invalidate any other reasons why the executable file might be covered by
 // the GNU General Public License.
 
-/** @file tr1/type_traitsfwd.h
+/** @file tr1_impl/type_traitsfwd.h
  *  This is an internal header file, included by other library headers.
  *  You should not attempt to use it directly.
  */
 
-#ifndef _TYPE_TRAITSFWD_H
-#define _TYPE_TRAITSFWD_H 1
-
-#include <cstddef>
-
-// namespace std::tr1
 namespace std
 {
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+_GLIBCXX_BEGIN_NAMESPACE_TR1
 
   /// @brief  helper classes [4.3].
   template<typename _Tp, _Tp __v>
@@ -112,9 +106,6 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
     struct is_volatile;
 
   template<typename _Tp>
-    struct is_pod;
-  
-  template<typename _Tp>
     struct is_empty;
   
   template<typename _Tp>
@@ -124,36 +115,9 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
     struct is_abstract;
   
   template<typename _Tp>
-    struct has_trivial_constructor;
-  
-  template<typename _Tp>
-    struct has_trivial_copy;
-
-  template<typename _Tp>
-    struct has_trivial_assign;
-  
-  template<typename _Tp>
-    struct has_trivial_destructor;
-  
-  template<typename _Tp>
-    struct has_nothrow_constructor;
-  
-  template<typename _Tp>
-    struct has_nothrow_copy;
-
-  template<typename _Tp>
-    struct has_nothrow_assign;
-  
-  template<typename _Tp>
     struct has_virtual_destructor;
   
   template<typename _Tp>
-    struct is_signed;
-  
-  template<typename _Tp>
-    struct is_unsigned;
-   
-  template<typename _Tp>
     struct alignment_of;
   
   template<typename _Tp>
@@ -166,12 +130,6 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   template<typename _Tp, typename _Up>
     struct is_same;
 
-  template<typename _From, typename _To>
-    struct is_convertible;
-
-  template<typename _Base, typename _Derived>
-    struct is_base_of;
-
   /// @brief  const-volatile modifications [4.7.1].
   template<typename _Tp>
     struct remove_const;
@@ -216,7 +174,5 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
   template<std::size_t _Len, std::size_t _Align>
     struct aligned_storage;
 
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_TR1
 }
-
-#endif
diff --git a/libstdc++-v3/include/tr1_impl/unordered_map b/libstdc++-v3/include/tr1_impl/unordered_map
new file mode 100644
index 0000000..a362296
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/unordered_map
@@ -0,0 +1,229 @@
+// TR1 unordered_map -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/unordered_map
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+  // XXX When we get typedef templates these class definitions
+  // will be unnecessary.
+  template<class _Key, class _Tp,
+	   class _Hash = hash<_Key>,
+	   class _Pred = std::equal_to<_Key>,
+	   class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
+	   bool __cache_hash_code = false>
+    class __unordered_map
+    : public _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
+			std::_Select1st<std::pair<const _Key, _Tp> >, _Pred, 
+			_Hash, __detail::_Mod_range_hashing,
+			__detail::_Default_ranged_hash,
+			__detail::_Prime_rehash_policy,
+			__cache_hash_code, false, true>
+    {
+      typedef _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
+			 std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
+			 _Hash, __detail::_Mod_range_hashing,
+			 __detail::_Default_ranged_hash,
+			 __detail::_Prime_rehash_policy,
+			 __cache_hash_code, false, true>
+        _Base;
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+
+      explicit
+      __unordered_map(size_type __n = 10,
+		      const hasher& __hf = hasher(),
+		      const key_equal& __eql = key_equal(),
+		      const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __detail::_Mod_range_hashing(),
+	      __detail::_Default_ranged_hash(),
+	      __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
+      { }
+
+      template<typename _InputIterator>
+        __unordered_map(_InputIterator __f, _InputIterator __l, 
+			size_type __n = 10,
+			const hasher& __hf = hasher(), 
+			const key_equal& __eql = key_equal(), 
+			const allocator_type& __a = allocator_type())
+	: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
+		__detail::_Default_ranged_hash(),
+		__eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
+	{ }
+    };
+  
+  template<class _Key, class _Tp,
+	   class _Hash = hash<_Key>,
+	   class _Pred = std::equal_to<_Key>,
+	   class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
+	   bool __cache_hash_code = false>
+    class __unordered_multimap
+    : public _Hashtable<_Key, std::pair<const _Key, _Tp>,
+			_Alloc,
+			std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
+			_Hash, __detail::_Mod_range_hashing,
+			__detail::_Default_ranged_hash,
+			__detail::_Prime_rehash_policy,
+			__cache_hash_code, false, false>
+    {
+      typedef _Hashtable<_Key, std::pair<const _Key, _Tp>,
+			 _Alloc,
+			 std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
+			 _Hash, __detail::_Mod_range_hashing,
+			 __detail::_Default_ranged_hash,
+			 __detail::_Prime_rehash_policy,
+			 __cache_hash_code, false, false>
+        _Base;
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+      
+      explicit
+      __unordered_multimap(size_type __n = 10,
+			   const hasher& __hf = hasher(),
+			   const key_equal& __eql = key_equal(),
+			   const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __detail::_Mod_range_hashing(),
+	      __detail::_Default_ranged_hash(),
+	      __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
+      { }
+
+
+      template<typename _InputIterator>
+        __unordered_multimap(_InputIterator __f, _InputIterator __l, 
+			     typename _Base::size_type __n = 0,
+			     const hasher& __hf = hasher(), 
+			     const key_equal& __eql = key_equal(), 
+			     const allocator_type& __a = allocator_type())
+	: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
+		__detail::_Default_ranged_hash(),
+		__eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
+        { }
+    };
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
+	   bool __cache_hash_code>
+    inline void
+    swap(__unordered_map<_Key, _Tp, _Hash, _Pred,
+	 _Alloc, __cache_hash_code>& __x,
+	 __unordered_map<_Key, _Tp, _Hash, _Pred,
+	 _Alloc, __cache_hash_code>& __y)
+    { __x.swap(__y); }
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
+	   bool __cache_hash_code>
+    inline void
+    swap(__unordered_multimap<_Key, _Tp, _Hash, _Pred,
+	 _Alloc, __cache_hash_code>& __x,
+	 __unordered_multimap<_Key, _Tp, _Hash, _Pred,
+	 _Alloc, __cache_hash_code>& __y)
+    { __x.swap(__y); }
+
+
+  template<class _Key, class _Tp,
+	   class _Hash = hash<_Key>,
+	   class _Pred = std::equal_to<_Key>,
+	   class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class unordered_map
+    : public __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
+    {
+      typedef __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>  _Base;
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+
+      explicit
+      unordered_map(size_type __n = 10,
+		    const hasher& __hf = hasher(),
+		    const key_equal& __eql = key_equal(),
+		    const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __eql, __a)
+      { }
+
+      template<typename _InputIterator>
+        unordered_map(_InputIterator __f, _InputIterator __l, 
+		      size_type __n = 10,
+		      const hasher& __hf = hasher(), 
+		      const key_equal& __eql = key_equal(), 
+		      const allocator_type& __a = allocator_type())
+	: _Base(__f, __l, __n, __hf, __eql, __a)
+        { }
+    };
+  
+  template<class _Key, class _Tp,
+	   class _Hash = hash<_Key>,
+	   class _Pred = std::equal_to<_Key>,
+	   class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class unordered_multimap
+    : public __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
+    {
+      typedef __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>  _Base;
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+      
+      explicit
+      unordered_multimap(size_type __n = 10,
+			 const hasher& __hf = hasher(),
+			 const key_equal& __eql = key_equal(),
+			 const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __eql, __a)
+      { }
+
+
+      template<typename _InputIterator>
+        unordered_multimap(_InputIterator __f, _InputIterator __l, 
+			   typename _Base::size_type __n = 0,
+			   const hasher& __hf = hasher(), 
+			   const key_equal& __eql = key_equal(), 
+			   const allocator_type& __a = allocator_type())
+	: _Base(__f, __l, __n, __hf, __eql, __a)
+        { }
+    };
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
diff --git a/libstdc++-v3/include/tr1_impl/unordered_set b/libstdc++-v3/include/tr1_impl/unordered_set
new file mode 100644
index 0000000..2292d36
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/unordered_set
@@ -0,0 +1,227 @@
+// TR1 unordered_set -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/unordered_set
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+namespace std
+{ 
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+  // XXX When we get typedef templates these class definitions
+  // will be unnecessary.
+  template<class _Value,
+	   class _Hash = hash<_Value>,
+	   class _Pred = std::equal_to<_Value>,
+	   class _Alloc = std::allocator<_Value>,
+	   bool __cache_hash_code = false>
+    class __unordered_set
+    : public _Hashtable<_Value, _Value, _Alloc,
+			std::_Identity<_Value>, _Pred,
+			_Hash, __detail::_Mod_range_hashing,
+			__detail::_Default_ranged_hash,
+			__detail::_Prime_rehash_policy,
+			__cache_hash_code, true, true>
+    {
+      typedef _Hashtable<_Value, _Value, _Alloc,
+			 std::_Identity<_Value>, _Pred,
+			 _Hash, __detail::_Mod_range_hashing,
+			 __detail::_Default_ranged_hash,
+			 __detail::_Prime_rehash_policy,
+			 __cache_hash_code, true, true>
+        _Base;
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+      
+      explicit
+      __unordered_set(size_type __n = 10,
+		      const hasher& __hf = hasher(),
+		      const key_equal& __eql = key_equal(),
+		      const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __detail::_Mod_range_hashing(),
+	      __detail::_Default_ranged_hash(), __eql,
+	      std::_Identity<_Value>(), __a)
+      { }
+
+      template<typename _InputIterator>
+        __unordered_set(_InputIterator __f, _InputIterator __l, 
+			size_type __n = 10,
+			const hasher& __hf = hasher(), 
+			const key_equal& __eql = key_equal(), 
+			const allocator_type& __a = allocator_type())
+	: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
+		__detail::_Default_ranged_hash(), __eql,
+		std::_Identity<_Value>(), __a)
+        { }
+    };
+
+  template<class _Value,
+	   class _Hash = hash<_Value>,
+	   class _Pred = std::equal_to<_Value>,
+	   class _Alloc = std::allocator<_Value>,
+	   bool __cache_hash_code = false>
+    class __unordered_multiset
+    : public _Hashtable<_Value, _Value, _Alloc,
+			std::_Identity<_Value>, _Pred,
+			_Hash, __detail::_Mod_range_hashing,
+			__detail::_Default_ranged_hash,
+			__detail::_Prime_rehash_policy,
+			__cache_hash_code, true, false>
+    {
+      typedef _Hashtable<_Value, _Value, _Alloc,
+			 std::_Identity<_Value>, _Pred,
+			 _Hash, __detail::_Mod_range_hashing,
+			 __detail::_Default_ranged_hash,
+			 __detail::_Prime_rehash_policy,
+			 __cache_hash_code, true, false>
+        _Base;
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+      
+      explicit
+      __unordered_multiset(size_type __n = 10,
+			   const hasher& __hf = hasher(),
+			   const key_equal& __eql = key_equal(),
+			   const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __detail::_Mod_range_hashing(),
+	      __detail::_Default_ranged_hash(), __eql,
+	      std::_Identity<_Value>(), __a)
+      { }
+
+
+      template<typename _InputIterator>
+        __unordered_multiset(_InputIterator __f, _InputIterator __l, 
+			     typename _Base::size_type __n = 0,
+			     const hasher& __hf = hasher(), 
+			     const key_equal& __eql = key_equal(), 
+			     const allocator_type& __a = allocator_type())
+	: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
+		__detail::_Default_ranged_hash(), __eql,
+		std::_Identity<_Value>(), __a)
+        { }
+    };
+
+  template<class _Value, class _Hash, class _Pred, class _Alloc,
+	   bool __cache_hash_code>
+    inline void
+    swap (__unordered_set<_Value, _Hash, _Pred,
+	  _Alloc, __cache_hash_code>& __x,
+	  __unordered_set<_Value, _Hash, _Pred,
+	  _Alloc, __cache_hash_code>& __y)
+    { __x.swap(__y); }
+
+  template<class _Value, class _Hash, class _Pred, class _Alloc,
+	   bool __cache_hash_code>
+    inline void
+    swap(__unordered_multiset<_Value, _Hash, _Pred,
+	 _Alloc, __cache_hash_code>& __x,
+	 __unordered_multiset<_Value, _Hash, _Pred,
+	 _Alloc, __cache_hash_code>& __y)
+    { __x.swap(__y); }
+
+
+  template<class _Value,
+	   class _Hash = hash<_Value>,
+	   class _Pred = std::equal_to<_Value>,
+	   class _Alloc = std::allocator<_Value> >
+    class unordered_set
+    : public __unordered_set<_Value, _Hash, _Pred, _Alloc>
+    {
+      typedef __unordered_set<_Value, _Hash, _Pred, _Alloc>  _Base;
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+      
+      explicit
+      unordered_set(size_type __n = 10,
+		    const hasher& __hf = hasher(),
+		    const key_equal& __eql = key_equal(),
+		    const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __eql, __a)
+      { }
+
+      template<typename _InputIterator>
+        unordered_set(_InputIterator __f, _InputIterator __l, 
+		      size_type __n = 10,
+		      const hasher& __hf = hasher(), 
+		      const key_equal& __eql = key_equal(), 
+		      const allocator_type& __a = allocator_type())
+	: _Base(__f, __l, __n, __hf, __eql, __a)
+        { }
+    };
+
+  template<class _Value,
+	   class _Hash = hash<_Value>,
+	   class _Pred = std::equal_to<_Value>,
+	   class _Alloc = std::allocator<_Value> >
+    class unordered_multiset
+    : public __unordered_multiset<_Value, _Hash, _Pred, _Alloc>
+    {
+      typedef __unordered_multiset<_Value, _Hash, _Pred, _Alloc>  _Base;
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+      
+      explicit
+      unordered_multiset(size_type __n = 10,
+			 const hasher& __hf = hasher(),
+			 const key_equal& __eql = key_equal(),
+			 const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __eql, __a)
+      { }
+
+
+      template<typename _InputIterator>
+        unordered_multiset(_InputIterator __f, _InputIterator __l, 
+			   typename _Base::size_type __n = 0,
+			   const hasher& __hf = hasher(), 
+			   const key_equal& __eql = key_equal(), 
+			   const allocator_type& __a = allocator_type())
+	: _Base(__f, __l, __n, __hf, __eql, __a)
+        { }
+    };
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
diff --git a/libstdc++-v3/include/tr1_impl/utility b/libstdc++-v3/include/tr1_impl/utility
new file mode 100644
index 0000000..42040c9
--- /dev/null
+++ b/libstdc++-v3/include/tr1_impl/utility
@@ -0,0 +1,98 @@
+
+// TR1 utility -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/utility
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+  template<class _Tp> class tuple_size;
+  template<int _Int, class _Tp> class tuple_element;
+
+   // Various functions which give std::pair a tuple-like interface.
+  template<class _Tp1, class _Tp2>
+    struct tuple_size<std::pair<_Tp1, _Tp2> >
+    { static const int value = 2; };
+
+  template<class _Tp1, class _Tp2>
+    const int tuple_size<std::pair<_Tp1, _Tp2> >::value;
+
+  template<class _Tp1, class _Tp2>
+    struct tuple_element<0, std::pair<_Tp1, _Tp2> >
+    { typedef _Tp1 type; };
+ 
+  template<class _Tp1, class _Tp2>
+    struct tuple_element<1, std::pair<_Tp1, _Tp2> >
+    { typedef _Tp2 type; };
+ 
+
+  template<int _Int> struct __pair_get;
+
+  template<>
+    struct __pair_get<0>
+    {
+      template<typename _Tp1, typename _Tp2>
+      static _Tp1& __get(std::pair<_Tp1, _Tp2>& __pair)
+      { return __pair.first; }
+
+      template<typename _Tp1, typename _Tp2>
+      static const _Tp1& __const_get(const std::pair<_Tp1, _Tp2>& __pair)
+      { return __pair.first; }
+    };
+
+  template<>
+    struct __pair_get<1>
+    {
+      template<typename _Tp1, typename _Tp2>
+      static _Tp2& __get(std::pair<_Tp1, _Tp2>& __pair)
+      { return __pair.second; }
+
+      template<typename _Tp1, typename _Tp2>
+      static const _Tp2& __const_get(const std::pair<_Tp1, _Tp2>& __pair)
+      { return __pair.second; }
+    };
+
+   template<int _Int, class _Tp1, class _Tp2>
+     inline typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
+     get(std::pair<_Tp1, _Tp2>& __in)
+     { return __pair_get<_Int>::__get(__in); }
+ 
+   template<int _Int, class _Tp1, class _Tp2>
+     inline const typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
+     get(const std::pair<_Tp1, _Tp2>& __in)
+     { return __pair_get<_Int>::__const_get(__in); }
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
+
diff --git a/libstdc++-v3/testsuite/20_util/has_nothrow_copy_constructor/value.cc b/libstdc++-v3/testsuite/20_util/has_nothrow_copy_constructor/value.cc
index ac79317..3a1ff3d 100644
--- a/libstdc++-v3/testsuite/20_util/has_nothrow_copy_constructor/value.cc
+++ b/libstdc++-v3/testsuite/20_util/has_nothrow_copy_constructor/value.cc
@@ -29,7 +29,7 @@ void test01()
   using std::has_nothrow_copy_constructor;
   using namespace __gnu_test;
 
-  VERIFY( (test_category<has_nothrow_copy_constructor, void>(true)) );
+  // Positive tests.
   VERIFY( (test_category<has_nothrow_copy_constructor, int>(true)) );
   VERIFY( (test_category<has_nothrow_copy_constructor, float>(true)) );
   VERIFY( (test_category<has_nothrow_copy_constructor, EnumType>(true)) );
@@ -45,6 +45,9 @@ void test01()
   VERIFY( (test_category<has_nothrow_copy_constructor, int (ClassType::*[2][3])>(true)) );
   VERIFY( (test_category<has_nothrow_copy_constructor,
 	   int (ClassType::*[][2][3]) (int)>(true)) );
+
+  // Negative tests.
+  VERIFY( (test_category<has_nothrow_copy_constructor, void>(false)) );
 }
 
 int main()
diff --git a/libstdc++-v3/testsuite/20_util/has_nothrow_default_constructor/value.cc b/libstdc++-v3/testsuite/20_util/has_nothrow_default_constructor/value.cc
index fccbcf7..839b9cc 100644
--- a/libstdc++-v3/testsuite/20_util/has_nothrow_default_constructor/value.cc
+++ b/libstdc++-v3/testsuite/20_util/has_nothrow_default_constructor/value.cc
@@ -31,7 +31,7 @@ void test01()
   using std::has_nothrow_default_constructor;
   using namespace __gnu_test;
 
-  VERIFY( (test_category<has_nothrow_default_constructor, void>(true)) );
+  // Positive tests.  
   VERIFY( (test_category<has_nothrow_default_constructor, int>(true)) );
   VERIFY( (test_category<has_nothrow_default_constructor, float>(true)) );
   VERIFY( (test_category<has_nothrow_default_constructor, EnumType>(true)) );
@@ -50,6 +50,9 @@ void test01()
   VERIFY( (test_category<has_nothrow_default_constructor,
 	   int (ClassType::*[][2][3]) (int)>(true)) );
   VERIFY( (test_category<has_nothrow_default_constructor, ClassType>(true)) );
+
+  // Negative tests.
+  VERIFY( (test_category<has_nothrow_default_constructor, void>(false)) );  
 }
 
 int main()
diff --git a/libstdc++-v3/testsuite/20_util/has_trivial_copy_constructor/value.cc b/libstdc++-v3/testsuite/20_util/has_trivial_copy_constructor/value.cc
index 2ea418a..98eb81a 100644
--- a/libstdc++-v3/testsuite/20_util/has_trivial_copy_constructor/value.cc
+++ b/libstdc++-v3/testsuite/20_util/has_trivial_copy_constructor/value.cc
@@ -31,7 +31,7 @@ void test01()
   using std::has_trivial_copy_constructor;
   using namespace __gnu_test;
 
-  VERIFY( (test_category<has_trivial_copy_constructor, void>(true)) );
+  // Positive tests.
   VERIFY( (test_category<has_trivial_copy_constructor, int>(true)) );
   VERIFY( (test_category<has_trivial_copy_constructor, float>(true)) );
   VERIFY( (test_category<has_trivial_copy_constructor, EnumType>(true)) );
@@ -47,6 +47,9 @@ void test01()
   VERIFY( (test_category<has_trivial_copy_constructor, int (ClassType::*[2][3])>(true)) );
   VERIFY( (test_category<has_trivial_copy_constructor,
 	   int (ClassType::*[][2][3]) (int)>(true)) );
+
+  // Negative tests.  
+  VERIFY( (test_category<has_trivial_copy_constructor, void>(false)) );  
 }
 
 int main()
diff --git a/libstdc++-v3/testsuite/20_util/has_trivial_default_constructor/value.cc b/libstdc++-v3/testsuite/20_util/has_trivial_default_constructor/value.cc
index fae5ace9..dfb707b 100644
--- a/libstdc++-v3/testsuite/20_util/has_trivial_default_constructor/value.cc
+++ b/libstdc++-v3/testsuite/20_util/has_trivial_default_constructor/value.cc
@@ -31,7 +31,7 @@ void test01()
   using std::has_trivial_default_constructor;
   using namespace __gnu_test;
 
-  VERIFY( (test_category<has_trivial_default_constructor, void>(true)) );
+  // Positive tests.
   VERIFY( (test_category<has_trivial_default_constructor, int>(true)) );
   VERIFY( (test_category<has_trivial_default_constructor, float>(true)) );
   VERIFY( (test_category<has_trivial_default_constructor, EnumType>(true)) );
@@ -50,6 +50,9 @@ void test01()
   VERIFY( (test_category<has_trivial_default_constructor,
 	   int (ClassType::*[][2][3]) (int)>(true)) );
   VERIFY( (test_category<has_trivial_default_constructor, ClassType>(true)) );
+
+  // Negative tests.
+  VERIFY( (test_category<has_trivial_default_constructor, void>(false)) );  
 }
 
 int main()
diff --git a/libstdc++-v3/testsuite/20_util/headers/type_traits/types_std_c++0x_neg.cc b/libstdc++-v3/testsuite/20_util/headers/type_traits/types_std_c++0x_neg.cc
index baeb71e..37c5a03 100644
--- a/libstdc++-v3/testsuite/20_util/headers/type_traits/types_std_c++0x_neg.cc
+++ b/libstdc++-v3/testsuite/20_util/headers/type_traits/types_std_c++0x_neg.cc
@@ -30,8 +30,8 @@ namespace gnu
   using std::has_nothrow_copy;
 }
 
-// { dg-error "has not been declared" "" { xfail *-*-* } 27 } 
-// { dg-error "has not been declared" "" { xfail *-*-* } 28 } 
-// { dg-error "has not been declared" "" { xfail *-*-* } 29 } 
-// { dg-error "has not been declared" "" { xfail *-*-* } 30 } 
+// { dg-error "has not been declared" "" { target *-*-* } 27 } 
+// { dg-error "has not been declared" "" { target *-*-* } 28 } 
+// { dg-error "has not been declared" "" { target *-*-* } 29 } 
+// { dg-error "has not been declared" "" { target *-*-* } 30 } 
 
diff --git a/libstdc++-v3/testsuite/20_util/is_signed/requirements/explicit_instantiation.cc b/libstdc++-v3/testsuite/20_util/is_signed/requirements/explicit_instantiation.cc
new file mode 100644
index 0000000..60d18d6
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/is_signed/requirements/explicit_instantiation.cc
@@ -0,0 +1,40 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+// 2007-04-30 Benjamin Kosnik <bkoz@redhat.com>
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+// NB: This file is for testing type_traits with NO OTHER INCLUDES.
+
+#include <type_traits>
+
+namespace std
+{
+  typedef short test_type;
+  template struct is_signed<test_type>;
+}
diff --git a/libstdc++-v3/testsuite/20_util/is_signed/requirements/typedefs.cc b/libstdc++-v3/testsuite/20_util/is_signed/requirements/typedefs.cc
new file mode 100644
index 0000000..5c7e882
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/is_signed/requirements/typedefs.cc
@@ -0,0 +1,37 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-24  Paolo Carlini  <pcarlini@suse.de>
+//
+// Copyright (C) 2005 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 
+// NB: This file is for testing type_traits with NO OTHER INCLUDES.
+
+#include <type_traits>
+
+// { dg-do compile }
+
+void test01()
+{
+  // Check for required typedefs
+  typedef std::is_signed<int>                 test_type;
+  typedef test_type::value_type               value_type;
+  typedef test_type::type                     type;
+  typedef test_type::type::value_type         type_value_type;
+  typedef test_type::type::type               type_type;
+}
diff --git a/libstdc++-v3/testsuite/20_util/is_signed/value.cc b/libstdc++-v3/testsuite/20_util/is_signed/value.cc
new file mode 100644
index 0000000..fcf84e7
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/is_signed/value.cc
@@ -0,0 +1,61 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-24  Paolo Carlini  <pcarlini@suse.de>
+//
+// Copyright (C) 2005 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+#include <type_traits>
+#include <testsuite_hooks.h>
+#include <testsuite_tr1.h>
+
+void test01()
+{
+  bool test __attribute__((unused)) = true;
+  using std::is_signed;
+  using namespace __gnu_test;
+  
+  VERIFY( (test_category<is_signed, void>(false)) );
+  
+  VERIFY( (test_category<is_signed, char>(char(-1) < char(0))) );
+  VERIFY( (test_category<is_signed, signed char>(true)) );
+  VERIFY( (test_category<is_signed, unsigned char>(false)) );
+#ifdef _GLIBCXX_USE_WCHAR_T
+  VERIFY( (test_category<is_signed, wchar_t>(wchar_t(-1) < wchar_t(0))) );
+#endif
+  VERIFY( (test_category<is_signed, short>(true)) );
+  VERIFY( (test_category<is_signed, unsigned short>(false)) );
+  VERIFY( (test_category<is_signed, int>(true)) );
+  VERIFY( (test_category<is_signed, unsigned int>(false)) );
+  VERIFY( (test_category<is_signed, long>(true)) );
+  VERIFY( (test_category<is_signed, unsigned long>(false)) );
+  VERIFY( (test_category<is_signed, long long>(true)) );
+  VERIFY( (test_category<is_signed, unsigned long long>(false)) );
+
+  VERIFY( (test_category<is_signed, float>(true)) );
+  VERIFY( (test_category<is_signed, double>(true)) );
+  VERIFY( (test_category<is_signed, long double>(true)) );
+
+  // Sanity check.
+  VERIFY( (test_category<is_signed, ClassType>(false)) );
+}
+
+int main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/is_unsigned/requirements/explicit_instantiation.cc b/libstdc++-v3/testsuite/20_util/is_unsigned/requirements/explicit_instantiation.cc
new file mode 100644
index 0000000..2cef363
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/is_unsigned/requirements/explicit_instantiation.cc
@@ -0,0 +1,40 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+// 2007-04-30 Benjamin Kosnik <bkoz@redhat.com>
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+// NB: This file is for testing type_traits with NO OTHER INCLUDES.
+
+#include <type_traits>
+
+namespace std
+{
+  typedef short test_type;
+  template struct is_unsigned<test_type>;
+}
diff --git a/libstdc++-v3/testsuite/20_util/is_unsigned/requirements/typedefs.cc b/libstdc++-v3/testsuite/20_util/is_unsigned/requirements/typedefs.cc
new file mode 100644
index 0000000..14f3846
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/is_unsigned/requirements/typedefs.cc
@@ -0,0 +1,37 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-24  Paolo Carlini  <pcarlini@suse.de>
+//
+// Copyright (C) 2005 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 
+// NB: This file is for testing type_traits with NO OTHER INCLUDES.
+
+#include <type_traits>
+
+// { dg-do compile }
+
+void test01()
+{
+  // Check for required typedefs
+  typedef std::is_unsigned<int>               test_type;
+  typedef test_type::value_type               value_type;
+  typedef test_type::type                     type;
+  typedef test_type::type::value_type         type_value_type;
+  typedef test_type::type::type               type_type;
+}
diff --git a/libstdc++-v3/testsuite/20_util/is_unsigned/value.cc b/libstdc++-v3/testsuite/20_util/is_unsigned/value.cc
new file mode 100644
index 0000000..d924163
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/is_unsigned/value.cc
@@ -0,0 +1,61 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-24  Paolo Carlini  <pcarlini@suse.de>
+//
+// Copyright (C) 2005 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+#include <type_traits>
+#include <testsuite_hooks.h>
+#include <testsuite_tr1.h>
+
+void test01()
+{
+  bool test __attribute__((unused)) = true;
+  using std::is_unsigned;
+  using namespace __gnu_test;
+  
+  VERIFY( (test_category<is_unsigned, void>(false)) );
+  
+  VERIFY( (test_category<is_unsigned, char>(char(-1) > char(0))) );
+  VERIFY( (test_category<is_unsigned, signed char>(false)) );
+  VERIFY( (test_category<is_unsigned, unsigned char>(true)) );
+#ifdef _GLIBCXX_USE_WCHAR_T
+  VERIFY( (test_category<is_unsigned, wchar_t>(wchar_t(-1) > wchar_t(0))) );
+#endif
+  VERIFY( (test_category<is_unsigned, short>(false)) );
+  VERIFY( (test_category<is_unsigned, unsigned short>(true)) );
+  VERIFY( (test_category<is_unsigned, int>(false)) );
+  VERIFY( (test_category<is_unsigned, unsigned int>(true)) );
+  VERIFY( (test_category<is_unsigned, long>(false)) );
+  VERIFY( (test_category<is_unsigned, unsigned long>(true)) );
+  VERIFY( (test_category<is_unsigned, long long>(false)) );
+  VERIFY( (test_category<is_unsigned, unsigned long long>(true)) );
+
+  VERIFY( (test_category<is_unsigned, float>(false)) );
+  VERIFY( (test_category<is_unsigned, double>(false)) );
+  VERIFY( (test_category<is_unsigned, long double>(false)) );
+
+  // Sanity check.
+  VERIFY( (test_category<is_unsigned, ClassType>(false)) );
+}
+
+int main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc b/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc
index 063c12eb..044f979 100644
--- a/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc
+++ b/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc
@@ -49,8 +49,8 @@ void test01()
 // { dg-error "instantiated from here" "" { target *-*-* } 41 }
 // { dg-error "instantiated from here" "" { target *-*-* } 43 }
 
-// { dg-error "invalid use of incomplete type" "" { target *-*-* } 291 }
-// { dg-error "declaration of" "" { target *-*-* } 253 }
+// { dg-error "invalid use of incomplete type" "" { target *-*-* } 424 }
+// { dg-error "declaration of" "" { target *-*-* } 390 }
 
 // { dg-excess-errors "At global scope" }
 // { dg-excess-errors "In instantiation of" }
diff --git a/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc b/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc
index 79277a7..f12d941 100644
--- a/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc
+++ b/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc
@@ -49,8 +49,8 @@ void test01()
 // { dg-error "instantiated from here" "" { target *-*-* } 41 }
 // { dg-error "instantiated from here" "" { target *-*-* } 43 }
 
-// { dg-error "invalid use of incomplete type" "" { target *-*-* } 208 }
-// { dg-error "declaration of" "" { target *-*-* } 170 }
+// { dg-error "invalid use of incomplete type" "" { target *-*-* } 345 }
+// { dg-error "declaration of" "" { target *-*-* } 311 }
 
 // { dg-excess-errors "At global scope" }
 // { dg-excess-errors "In instantiation of" }
diff --git a/libstdc++-v3/testsuite/20_util/tuple/requirements/explicit_instantiation.cc b/libstdc++-v3/testsuite/20_util/tuple/requirements/explicit_instantiation.cc
index cdead8f..55afcc8 100644
--- a/libstdc++-v3/testsuite/20_util/tuple/requirements/explicit_instantiation.cc
+++ b/libstdc++-v3/testsuite/20_util/tuple/requirements/explicit_instantiation.cc
@@ -30,4 +30,4 @@
 
 #include <tr1/tuple>
 
-template class std::tuple<short, int, double>;
+template class std::tr1::tuple<short, int, double>;
diff --git a/libstdc++-v3/testsuite/tr1/headers.cc b/libstdc++-v3/testsuite/tr1/headers/all.cc
index 633b8fb..633b8fb 100644
--- a/libstdc++-v3/testsuite/tr1/headers.cc
+++ b/libstdc++-v3/testsuite/tr1/headers/all.cc
diff --git a/libstdc++-v3/testsuite/tr1/headers/c++200x/using_namespace_std_tr1.cc b/libstdc++-v3/testsuite/tr1/headers/c++200x/using_namespace_std_tr1.cc
new file mode 100644
index 0000000..0d74636
--- /dev/null
+++ b/libstdc++-v3/testsuite/tr1/headers/c++200x/using_namespace_std_tr1.cc
@@ -0,0 +1,27 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+#include <tr1/tuple>
+
+namespace gnu
+{
+  using namespace std::tr1;
+}
diff --git a/libstdc++-v3/testsuite/tr1/using_namespace_std_tr1.cc b/libstdc++-v3/testsuite/tr1/headers/using_namespace_std_tr1.cc
index 21fc682..21fc682 100644
--- a/libstdc++-v3/testsuite/tr1/using_namespace_std_tr1.cc
+++ b/libstdc++-v3/testsuite/tr1/headers/using_namespace_std_tr1.cc