egcs projects compiler system

Exact copy of the snapshot, except for the removal of
	texinfo/
	gcc/ch/
	libchill/

166 files changed, 32257 insertions, 0 deletions

diff --git a/gnu/egcs/libstdc++/ChangeLog b/gnu/egcs/libstdc++/ChangeLog
new file mode 100644
index 00000000000..f6fa7dd3838
--- /dev/null
+++ b/gnu/egcs/libstdc++/ChangeLog
@@ -0,0 +1,1291 @@
+1999-05-15  Mark Kettenis  <kettenis@gnu.org>
+
+	* configure.in: Add shared library support for the Hurd
+	(*-*-gnu*).
+	* config/gnu.ml: New file.
+
+1999-05-12  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* configure.in (compiler_name): Don't do the skip-this-dir thing
+	if we're reconfiguring.
+
+1999-05-07  Ulrich Drepper  <drepper@cygnus.com>
+
+	* std/bastring.h (class basic_string::Rep): Make release member
+	function thread-safe for ix86 (x>=4) and UltraSPARC.
+
+	* stlinst.cc: Make it possible to compile with __USE_MALLOC.
+
+Mon Apr 26 02:24:47 1999 "Loren J. Rittle" <rittle@supra.rsch.comm.mot.com>
+
+	* config/freebsd.ml (LIBS): Add ARLINK.
+	* config/openbsd.ml (LIBS): Add ARLINK.
+
+Fri Apr  2 15:12:14 1999  H.J. Lu  (hjl@gnu.org)
+
+	* libstdc++/configure.in (gxx_include_dir): Handle it.
+	* libstdc++/Makefile.in: Likewise.
+
+Wed Mar 24 22:36:45 1999  Mumit Khan  <khan@xraylith.wisc.edu>
+
+	* configure.in (EXEEXT): Define.
+	(compiler_name): Use.
+
+Thu Mar 11 01:07:55 1999  Franz Sirl <Franz.Sirl-kernel@lauterbach.com>
+
+	* configure.in: Add mh-*pic handling for alpha, arm, powerpc
+
+Fri Mar  5 02:16:39 1999  Doug Rabson  <dfr@freebsd.org>
+
+	* configure.in: Support shared libs on FreeBSD 3.x and 4.x
+	* config/freebsd.ml: A copy of config/linux.ml since they are both
+	ELF and both have a shared libm.
+
+1999-02-24  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* configure.in: Fix INSTALLDIR sed pattern for Solaris sed.
+
+Sat Feb 20 13:17:17 1999  Jeffrey A Law  (law@cygnus.com)
+
+	* string, std/straits.h, std/bastring.h: Revert recent change.  Needs
+	some libiberty support before it can be re-enabled.
+
+Thu Feb 18 19:53:17 1999  Marc Espie <espie@cvs.openbsd.org>
+
+	* configure.in: Handle OpenBSD with and without threads.
+	* config/openbsd.ml: New file.
+	* config/openbsd.mt: New file.
+
+1999-02-04  Ulrich Drepper  <drepper@cygnus.com>
+
+	* configure.in: Recognize --enable-threads=posix for all
+	platforms.
+	* config/posix.mt: New file.
+
+	* configure.in: Add fragments for Solaris defining macro specifying
+	thread library to be used.
+	* config/sol2pth.mt: New file
+	* config/sol2solth.mt: New file.
+	* stl/stl_alloc.h: Add support for Solaris thread library.
+	* stl/stl_config.h: Recognize _SOLTHREADS and define internal macros
+	appropriately.
+
+1999-01-28  Baron Roberts  <baron@sgi.com>
+
+	* string: Uncomment wstring declaration.
+
+	* std/straits.h: Remove #if 0/#endif from around
+	struct string_char_traits <wchar_t>.
+	#include <cwchar>.
+	Add missing definition for wchar_t move method.
+	Add empty() method for trait-based empty string return.
+
+	* std/bastring.h (c_str): Change return of "" to return of
+	traits::empty() call so that proper empty string is returned
+	based on the character type (i.e. "" or L"").
+
+1999-02-07  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* Makefile.in (stuff2): Tweak.
+
+1999-02-04  Ulrich Drepper  <drepper@cygnus.com>
+
+	* configure.in: Recognize --enable-threads=posix for all
+	platforms.
+	* config/posix.mt: New file.
+
+	* configure.in: Add fragments for Solaris defining macro specifying
+	thread library to be used.
+	* config/sol2pth.mt: New file
+	* config/sol2solth.mt: New file.
+	* stl/stl_alloc.h: Add support for Solaris thread library.
+	* stl/stl_config.h: Recognize _SOLTHREADS and define internal macros
+	appropriately.
+
+Sat Jan 30 08:05:46 1999 Mumit Khan  <khan@xraylith.wisc.edu>
+
+	* config/x86-interix.ml: New file.
+	* configure.in (i[3456]86-*-interix*): Add shared library support.
+
+1999-01-13  Ulrich Drepper  <drepper@cygnus.com>
+
+	* configure.in: Test for "ln -s" and set LN_S in generated Makefile.
+	* Makefile.in: Use $(LN_S) instead of explicitly ln -s.
+
+Sun Jan 03 03:16:02 1999  Robert Lipe  <robertlipe@usa.net>
+
+	* configure.in:  (*-*-sysv5, *-*-*udk*):  Treat like sysv4.
+
+Tue Dec  8 00:59:09 1998  Marc Espie <Marc.Espie@liafa.jussieu.fr>
+
+	* Makefile.in: Be more selective about what files to install.
+
+1998-11-30  Ulrich Drepper  <drepper@cygnus.com>
+
+	* std/bastring.cc (operator>>): Correct cast in last patch.
+	(getline): Likewise.
+
+1998-11-27  Alexandre Oliva  <oliva@dcc.unicamp.br>
+
+	* Makefile.in (HEADERS): Install bitset.
+
+1998-11-26  Manfred Hollstein  <manfred@s-direktnet.de>
+
+	* configure.in (compiler_name): Add check to detect if this
+	language's compiler has been built.
+
+1998-11-23  Ulrich Drepper  <drepper@cygnus.com>
+
+	* std/bastring.cc (operator>>): Cast new character to char before
+	adding to string.
+	(getline): Likewise.
+
+Thu Sep 17 01:29:46 1998  H.J. Lu  (hjl@gnu.org)
+
+	* Makefile.in ($(ARLINK), $(SHLINK)): Don't rely on 'ln -f'.
+
+	* Makefile.in (install): Don't rely on 'ln -f'.
+
+1998-09-09  Manfred Hollstein  <manfred@s-direktnet.de>
+
+	* Makefile.in (install): Initialize RELINSTALLDIR correctly
+	even for multilib and cross configurations.
+
+	* configure.in (INSTALLDIR): Don't change INSTALLDIR's init
+	value if --enable-version-specific-runtime-libs has been specified.
+
+Wed Sep  2 21:11:15 1998  H.J. Lu  (hjl@gnu.org)
+
+	* Makefile.in (RELINSTALLDIR): New. Use it to make symlinks.
+
+	* configure.in: Fix INSTALLDIR replacement for cross-compile.
+
+Sun Aug 30 22:17:41 1998  H.J. Lu  (hjl@gnu.org)
+
+	* Makefile.in (INTERFACE): New, set to 2.
+	(ARLIB): Set to libstdc++.a.$(VERSION)
+	(ARLINK, MARLINK): New macros.
+	(LIBS): Add $(ARLINK).
+	($(ARLINK), marlink): New targets.
+	(install): Don't check $(libsubdir). Handle versioned libraries.
+
+	* config/linux.ml (ARLIB, MARLINK, SHLIB, MSHLINK): New macros.
+	(LIBS): Add marlink $(ARLINK).
+
+	* config/aix.ml (ARLIB): Set to libstdc++-ar.a.$(VERSION)
+	(ARLINK): New macros.
+	(BUILD_LIBS): Add $(ARLINK).
+
+	* config/dec-osf.ml (LIBS): Add $(ARLINK).
+	* config/elf.ml (LIBS): Likewise.
+	* config/elfshlibm.ml (LIBS): Likewise.
+	* config/hpux.ml (LIBS): Likewise.
+	* config/iris5.ml (LIBS): Likewise.
+	* config/sol2shm.ml (LIBS): Likewise.
+	* config/sunos4.ml (LIBS): Likewise.
+
+	* configure.in: Use ${topsrcdir}/config.if to put
+	LIBSTDCXX_INTERFACE, CXX_INTERFACE, LIBC_INTERFACE in
+	${package_makefile_frag}.
+
+1998-08-25  Martin von Löwis  <loewis@informatik.hu-berlin.de>
+
+	* stdexcept: Remove __HONOR_STD.
+
+1998-08-23  Mark Mitchell  <mark@markmitchell.com>
+
+	* sinst.cc: Don't explicitly instantiation string_char_traits<char>.
+	* cinst.cc: Likewiwse, for complex<float>, complex<double>,
+	complex<long double>.
+
+1998-08-17  Mark Mitchell  <mark@markmitchell.com>
+
+	* stdexcept: Put things in the std namespace, if appropriate.
+
+1998-07-12  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* Makefile.in (VERSION): Bump to 2.9.0.
+
+1998-07-12  Lars Albertsson <lalle@sics.se>
+
+	* std/bastring.cc (find_last_of): Fix.
+	(find_last_not_of): Likewise.
+
+1998-07-06  Manfred Hollstein  <manfred@s-direktnet.de>
+
+	* configure.in (INSTALLDIR): Make sed pattern failsafe.
+
+1998-07-06  Ulrich Drepper  <drepper@cygnus.com>
+
+	* std/bastring.h (class basic_string): Correct iterator return
+	values in insert member functions.
+
+1998-07-02  Ulrich Drepper  <drepper@cygnus.com>
+
+	* std/bastring.h (class basic_string): Return correct iterators in
+	erase member functions.
+
+1998-06-24  Manfred Hollstein  <manfred@s-direktnet.de>
+
+	* Makefile.in (INSTALLDIR): Add comment to document the fact,
+	this macro will be properly initialized at make's runtime.
+	(install): Add initialization of INSTALLDIR depending on $(libsubdir)
+	and ${enable_version_specific_runtime_libs}; use $${INSTALLDIR} shell
+	variable instead of the $(INSTALLDIR) make macro.
+
+Tue Mar 24 10:13:07 1998  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/bastring.cc (basic_string::copy): Mark const here, too.
+
+1998-03-23 15:59  Ulrich Drepper  <drepper@cygnus.com>
+
+	* std/bastring.h (basic_string::copy): Mark copy function as const.
+	Reported by Scott Schurr <scotts@ims.com>.
+
+Thu Mar  5 09:23:28 1998  Manfred Hollstein  <manfred@s-direktnet.de>
+
+	* configure.in: Make locating frag files failsafe even for the
+	special case if configuring and building in srcdir.
+
+1998-03-04 12:37  Ulrich Drepper <drepper@cygnus.com>
+
+	* cinst.cc [INSERT] (operator<<): Correct type of numeric argument.
+
+Fri Feb  6 01:36:21 1998  Manfred Hollstein  <manfred@s-direktnet.de>
+
+	* Makefile.in (piclist): Check value of enable_shared, not PICFLAG.
+	(stmp-string, ...): Dito.
+	(bigstmp-string, ...): Dito.
+
+Sun Feb  1 13:38:07 1998  H.J. Lu  (hjl@gnu.org)
+
+	* config/linux.mt: Don't define _PTHREADS, but define
+	_IO_MTSAFE_IO.
+
+Wed Jan 28 10:27:11 1998  Manfred Hollstein  <manfred@s-direktnet.de>
+
+        * tests/configure.in, testsuite/configure.in: Update with yesterday's
+	toplevel configure.in changes.
+
+Tue Jan 27 23:27:32 1998  Manfred Hollstein  <manfred@s-direktnet.de>
+
+	* configure.in (package_makefile_rules_frag): New variable
+	which is used in the call to config.shared; redirect file descriptor 2
+	to ${package_makefile_rules_frag}.
+
+Tue Jan 27 10:11:27 1998  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* Makefile.in (install): Remove the shared library symlink even if
+ 	we aren't installing it.
+
+Tue Jan 27 10:29:44 1998  H.J. Lu  (hjl@gnu.org)
+
+	* configure.in (topsrcdir): New.
+	(configdirs): Check ${topsrcdir}/gcc instead.
+	(config-ml.in): Use ${topsrcdir}/config-ml.in.
+
+	* tests/configure.in (topsrcdir): New.
+	(check): Check ${topsrcdir}/gcc instead.
+
+Sun Jan 25 14:01:50 1998  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/bastring.h (unique): We only need length bytes.
+	(c_str): Avoid writing over random memory.
+	#include <std/bastring.cc>.
+	Lose _G_ALLOC_CONTROL.
+	* std/bastring.cc: Likewise.
+ 	(nilRep): Add initializer for selfish.
+	* sinst.cc: Just #include <string>.
+
+Tue Jan 13 21:23:05 1998  H.J. Lu  (hjl@gnu.org)
+
+	* configure.in (configdirs): Include testsuite only if
+	${srcdir}/../gcc exists.
+
+	* tests/configure.in (check): Set to ${CHECK} if
+	${srcdir}/../../gcc doesn't exists.
+
+1998-01-05  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* std/bastring.cc (basic_string::Rep::operator delete): Don't claim
+	to return from deallocate, since this is a void method.
+
+Sat Jan  3 12:15:41 1998 Franz Sirl <franz.sirl-kernel@lauterbach.com>
+
+	* configure.in: Finalize support for {alpha|powerpc}*-*-linux-gnulibc1
+
+Sun Dec  7 02:34:40 1997  Jody Goldberg	<jodyg@idt.net>
+
+	* libstdc++/std/bastring.h : Move closer to the draft standard
+	implementation of basic_string by adding 3 paramter 'Allocator'.
+	NOTE: this still differs from the standard in not offering per
+	instance allocators.
+	* libstdc++/std/bastring.cc : Likewise.
+	* libstdc++/stlinst.cc : Handle thread safe allocators if they are the
+	default.
+
+Sun Dec  7 02:32:20 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* iosfwd: New header.
+	* Makefile.in (HEADERS): Add it.
+
+Sun Dec  7 02:32:20 1997  Gregory L. Galloway (gregg@eoeml.gtri.gatech.edu)
+
+	* Makefile.in (HEADERS): Modified list of headers to
+	install to include all of SGI STL headers especially hash_set and
+	hash_map, and added ANSI C++ style wrappers for fstream, iomanip,
+	iostream, and strstream.
+
+	* fstream, iomanip, iostream, strstream: New forwarding headers
+	added.
+
+Thu Nov 27 01:33:55 1997  Jeffrey A Law  (law@cygnus.com)
+
+	* Makefile.in (install): Change gxx_includedir to gxx_include_dir.
+
+Tue Nov 25 23:16:44 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	London changes to string:
+	* std/bastring.cc (check_realloc): Don't be selfish anymore.
+	* std/bastring.h (non-const operator[]): Be selfish.
+	(iterator forms of insert and erase): Stay selfish.
+
+Tue Nov 25 14:03:43 1997  H.J. Lu  (hjl@gnu.org)
+
+	* Makefile.in (stmp-complex, bigstmp-complex): Changed to
+	xxxx-complx.
+
+Mon Nov 24 14:41:33 1997  Jeffrey A Law  (law@cygnus.com)
+
+	* Makefile.in: Use ln -f -s, not ln -s -f.
+
+Fri Nov 21 12:56:24 1997  Manfred Hollstein <manfred@s-direktnet.de>
+
+	* Makefile.in (bigstmp-complex): Name changed to bigstmp-complx to
+	cope with filesystem not capable to handle names longer than
+	14 characters.
+
+Sun Nov 16 22:41:55 1997  Jeffrey A Law  (law@cygnus.com)
+
+	* Makefile.in (SHLIB): Build with CC instead of CXX.
+
+Sun Nov  2 23:34:09 1997  Manfred Hollstein  <manfred@s-direktnet.de>
+
+	* configure.in: Use delta.mt for m68k-motorola-sysv.
+	* config/delta.mt: New makefile fragment.
+
+Sun Nov  2 12:14:37 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* Makefile.in (install): Some of HEADERS come from the stl dir now.
+	* algorithm, deque, functional, iterator, list, map, memory, numeric,
+ 	queue, set, stack, utility, vector: Now in stl dir.
+
+Fri Oct 10 00:40:00 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/bastring.h: Use ibegin internally.  Return passed iterator
+	instead of recalculating it where appropriate.
+	* std/bastring.cc: Adjust for erase.
+
+	From Yotam Medini:
+	* std/bastring.h: Replace remove with erase.
+
+Thu Oct  9 23:24:36 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* stdexcepti.cc (__out_of_range): New fn.
+	(__length_error): New fn.
+
+	* std/bastring.h (OUTOFRANGE): Fix logic.  Use throwing functions.
+	(LENGTHERROR): Likewise.
+	Revert Oct 2 changes.
+	* string: Revert Oct 2 changes.
+
+Tue Oct  7 00:51:51 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/{f,d,ld}complex.h: Replace guiding fns if not -ansi.
+
+Thu Oct  2 00:08:18 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/bastring.h: Move exception stuff after definition of string.
+	Move typedef of string here.
+	* string: From here.
+
+Sat Sep 27 16:48:00 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/complext.h: Lose injection decls.
+	* std/fcomplex.h: Likewise.
+	* std/dcomplex.h: Likewise.
+	* std/ldcomplex.h: Likewise.
+
+Sat Sep 27 16:47:35 1997  Mark Mitchell  <mmitchell@usa.net>
+
+	* std/complext.h: Declare templates before making them
+	friends.  Use new friend <> syntax.
+	* std/complext.cc: Don't rely on guiding declarations.
+	* std/fcomplex.h: Use new friend <> syntax.
+	* std/dcomplex.h: Likewise.
+	* std/ldcomplex.h: Likewise.
+
+Thu Sep 25 19:55:56 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/bastring.h: Enable exceptions.
+ 	(assign, append, insert, replace): Implement member template versions.
+
+1997-09-15 02:37  Ulrich Drepper  <drepper@cygnus.com>
+
+	* config/linux.mt: New file.  Make sure _PTHREADS is defined
+	if necessary.
+	* configure.in: Find linux.mt file.
+
+Thu Sep 11 15:03:20 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/bastring.h (class basic_string): Add global scope to
+	use of reverse_iterator.
+
+Tue Sep  9 19:47:07 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/bastring.h: Adjust use of reverse_iterator template.
+
+Wed Aug 27 00:04:33 1997  Alexandre Oliva  (oliva@dcc.unicamp.br)
+
+	* Makefile.in: Create correct multiple links to
+	shared libstdc++.
+
+Tue Aug 26 12:24:01 1997  H.J. Lu  (hjl@gnu.ai.mit.edu)
+
+	* testsuite/Makefile.in (check): Don't depend on site.exp.
+	(just-check): Depend on site.exp.
+
+Mon Aug 25 14:26:45 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* Makefile.in (CXXFLAGS): Add -Weffc++.
+
+Sat Aug 23 21:25:37 1997  Mark Mitchell  <mmitchell@usa.net>
+
+	* bastring.h: Enable reverse_iterator and its ilk.
+
+	* bastring.h: Provide specializations of member function templates
+	for const_iterator.
+
+Wed Jul 30 10:59:00 1997  Benjamin Kosnik  <bkoz@rhino.cygnus.com>
+
+	* stlinst.cc: Add instantiation file for
+	__default_alloc_template<fale, 0> and
+	__malloc_alloc_template<0>
+
+Sun Jun  1 17:03:40 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/bastring.cc (find_last_of): Correct handling of POS.
+	(find_last_not_of): Likewise.
+
+Thu May  1 17:37:10 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* Makefile.in ($(SHLIB)): Add $(LIBCXXFLAGS).
+
+Wed Apr 30 12:06:23 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* Makefile.in (IO_DIR): Remove $(MULTIBUILDTOP).
+	(LIBIBERTY_DIR): Likewise.
+	* configure.in: Don't turn on multilib here.
+
+Fri Apr 25 16:09:15 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* testsuite/libstdc++.tests/test.exp, testsuite/lib/libstdc++.exp,
+	  testsuite/configure.in, testsuite/Makefile.in,
+	  testsuite/config/default.exp, testsuite/ChangeLog: New files.
+
+	* configure.in: Add new testsuite directory to be configured.
+
+Tue Apr 22 19:03:39 1997  Alexandre Oliva <oliva@dcc.unicamp.br>
+
+	* Makefile.in (install): Fix handling of mshlink.
+
+Fri Apr  4 03:25:13 1997  Ulrich Drepper  <drepper@cygnus.com>
+
+	* Makefile.in (IO_DIR): Prepend $(MULTIBUILDTOP) to
+	support multilib build.
+	(LIBIBERTY_DIR): Likewise.
+
+	* configure.in: Enable multilibing by default.
+	Update multilib template to read config-ml.in.
+
+Wed Mar 12 16:09:34 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* configure.in (XCXXINCLUDES): Add the STL directory.
+
+Thu Jan 23 08:08:43 1997  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* stdexcept: Delete dtors for all of the error classes, to match
+	their removal in the Apr 1995 WP.
+ 	(class overflow_error): Define missing class, added in May 1996 WP.
+
+Mon Nov 18 16:57:25 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* Makefile.in (stuff[12]): More rules for my own evil purposes.
+	(CXXFLAGS, CFLAGS): Use -O instead of -O3 so debugging works.
+
+Wed Oct 16 13:47:45 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* config/irix5.ml: Do link against the math library.
+	* configure.in: Support shared libs on Irix 6.
+
+Fri Oct 11 18:06:09 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* config/linux.ml: Lose version overrides.
+
+	* Makefile.in (MSHLINK): Defaults to .so.2.x
+	(mshlink): Indirect rule for making it.
+
+Tue Sep 24 17:58:31 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* Remove new, typeinfo, exception, stddef*.
+	* Move public headers from std/*.h to *.
+
+Sun Sep 22 05:35:55 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* Makefile.in: Remove new, exception, typeinfo handling.
+	* exceptioni.cc, newi.cc, typeinfoi.cc, std/exception.h, std/new.h,
+	std/typeinfo.h, new.h: Remove.
+	* typeinfo, new, exception: Refer to the files with .h in gcc.
+
+Fri Sep 20 14:39:19 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* Makefile.in: Remove references to stl.list.
+	* configure.in (configdirs): Remove stl.
+
+Sat Sep 14 09:42:08 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* Makefile.in (stuff): Convenience for me.
+
+	* std/bastring.h: Remove kludge obsoleted by new overloading code.
+
+Fri Sep  6 16:43:21 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* typeinfoi.cc (__dynamic_cast): Fix static_cast.
+	(__rtti_si): Likewise.
+	(dcast): Likewise.
+
+Thu Aug 29 17:06:23 1996  Michael Meissner  <meissner@tiktok.cygnus.com>
+
+	* configure.in (i[345]86-*-*): Recognize i686 for pentium pro.
+
+Tue Jul 23 14:27:44 1996  Mike Stump  <mrs@cygnus.com>
+
+	* Makefile.in (exceptioni.o): Use -fexceptions now.
+
+Mon Jun 17 13:57:24 1996  Per Bothner  <bothner@deneb.cygnus.com>
+
+	* std/bastring.h (class basic_string::remove):  Add casts.
+
+	* configure.in:  Use EXTRA_DISTCLEAN rather than DISTCLEAN.
+
+Fri Jun  7 14:09:20 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* typeinfoi.cc (BUILTIN): Align typeinfo object like a pointer.
+
+Wed May 29 16:48:35 1996  Mike Stump  <mrs@cygnus.com>
+
+	* exceptioni.cc (__throw_bad_exception): Add.
+	* std/exception.h (bad_exception): Add.
+	* std/typeinfo.h: Remove leftovers of bad_cast_object.
+
+Mon May  6 14:04:42 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/complext.h: s/FLOAT/_FLT/g.
+
+Thu May  2 17:26:24 1996  Mike Stump  <mrs@cygnus.com>
+
+	* exceptioni.cc (uncaught_exception): New routine.
+	* std/exception.h: Declare it.
+
+Thu Apr 25 13:20:57 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* Makefile.in (typeinfoi.o, stdexcepti.o): Use default rule.
+
+Wed Apr 24 18:38:24 1996  Mike Stump  <mrs@cygnus.com>
+
+	* exceptioni.cc: Add #pragma implementation.
+	* std/exception.h: Add #pragma interface.  Moved exception from
+	stdexcept.
+	* std/stdexcept.h: Moved exception to exception.  Fix all constructor
+	arguments to take strings to match ANSI.  Moved bad_cast and bad_typeid
+	to typeinfo.
+	* std/typeinfo.h: Moved bad_cast and bad_typeid from stdexcept.
+
+Wed Apr 24 10:43:07 1996  Doug Evans  <dje@blues.cygnus.com>
+
+	* Makefile.in (newi.o,cstringi.o,stddefi.o,cstdlibi.o,cmathi.o): Add
+	rules for SunOS VPATH.
+
+Fri Apr 19 17:24:51 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* Version 2.8.0b3.
+
+Wed Apr 10 14:38:05 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* typeinfoi.cc (base_info): Pack the latter three fields into 32 bits.
+
+Tue Apr  9 15:49:38 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* typeinfoi.cc: Add 'const'.
+	(__class_type_info): Now just one pointer to an array of structs,
+	rather than four pointers to arrays.
+
+	* typeinfoi.cc (__throw_type_match_rtti): Check for conversion to
+	void* before conversion to base*.
+	(dcast): Handle downcasting to X* given other X	subobjects in
+	the most derived type.  Ack.
+
+Mon Apr  8 15:20:32 1996  Ian Lance Taylor  <ian@cygnus.com>
+
+	* configure.in: Permit --enable-shared to specify a list of
+	directories.
+
+Sun Apr  7 22:50:53 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* typeinfoi.cc (__rtti_array): New entry point.
+
+Sat Apr  6 14:41:18 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* exceptioni.cc (__throw_bad_cast): New entry point for compiler.
+	* typeinfoi.cc: Remove __bad_cast_object.
+
+	* typeinfoi.cc: Add nodes for unsigned builtins.
+
+Fri Apr  5 18:16:22 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* typeinfoi.cc, std/typeinfo.h: Total overhaul.  Move most
+ 	everything out of the header, move name field into type_info, add
+ 	single-inheritance case, rewrite pointer handling, add new
+ 	compiler interface.  Compare addresses to check for equality.
+
+Wed Mar 27 11:54:08 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* Version 2.8.0b2.
+
+Fri Mar  8 13:56:18 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/[cs]inst.h: Remove.
+
+Thu Mar  7 07:29:00 1996  Lee Iverson  <leei@Canada.AI.SRI.COM>
+
+	* Makefile.in (install): Restore deleted chdir to stl subdir.
+
+Thu Mar  7 15:02:58 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/complext.h: Fix __attribute__ usage.
+
+Wed Feb 28 10:00:24 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* Version 2.8.0b1.
+
+Mon Feb 26 17:26:26 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/cstring.h: New approach to changing signatures of string
+ 	manipulation functions.  Still disabled.
+
+Tue Feb 20 18:29:30 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/complext.h (__doapl, __doami, __doaml, __doadv): Helper
+ 	templates to implement +=, -=, *= and /=, respectively, since
+ 	member function templates do not apply to class specializations.
+	* std/{f,d,ld}complex.h, std/complext.cc, cinst.cc: Adjust.
+
+	* std/bastring.h: The representation class is now a nested class.
+	* std/bastring.cc: Add templates for static data members.
+	* sinst.cc: Don't provide specializations for static data members.
+	* std/string.h: Use default template parameters.
+
+	* Makefile.in (CXXFLAGS): Remove -pedantic -ansi.
+	(CFLAGS): Ditto.
+
+Wed Feb 14 14:39:07 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/bastring.cc (check_realloc): Fix for sizeof (charT) > 1.
+	From John Hickin <hickin@bnr.ca>.
+
+Wed Jan 10 11:05:04 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/bastring.h (insert): Fix iterator handling.
+	From Joe Buck <jbuck@synopsys.com>.
+
+Mon Jan  8 11:48:03 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/bastring.h (max_size): Fix for sizeof (charT) > 1.
+	* std/bastring.cc (replace): Use it.
+
+	* std/bastring.cc (rfind): Fix for n > length ().
+
+Tue Dec 19 15:13:08 1995  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* config/aix.ml (SHFLAGS): Add -Wl,-unix.
+
+Mon Dec 18 12:48:25 1995  Mike Stump  <mrs@cygnus.com>
+
+	* Makefile.in (exceptioni.o): Compile with -fhandle-exceptions, so
+	we can unwind through unexpected on machines that don't have a
+	working __unwind_function.
+
+Sun Dec 17 00:28:31 1995  Jeffrey A Law  (law@cygnus.com)
+
+	* Makefile.in (install): Make sure shared libraries
+	are installed with mode 555.
+
+Mon Nov 27 15:01:56 1995  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* Makefile.in (install): Make shared library links relative.
+	(install): Break up -sf into -s -f.
+	({M,}SHLINK): Ditto.
+
+Sun Nov 26 22:48:06 1995  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* queue: Include <stack.h> instead of <queue.h>.
+
+Sat Nov 25 11:33:13 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* Makefile.in (install): Fix setting of rootme.
+
+Tue Nov 21 14:20:34 1995  Ian Lance Taylor  <ian@cygnus.com>
+
+	* configure.in: Check ${with_cross_host} rather than comparing
+	${host} and ${target}.
+
+Tue Nov 14 01:50:52 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* Makefile.in (IO_DIR): Delete MULTITOP, MULTISUBDIR.
+	(LIBIBERTY_DIR): Likewise.
+	(INSTALLDIR): Delete MULTISUBDIR.
+	* configure.in: Delete call to cfg-ml-com.in.  Call config-ml.in
+	instead of cfg-ml-pos.in.
+	(XCXXINCLUDES): Delete MULTITOP.
+	* stl/configure.in (XCXXINCLUDES): Delete MULTITOP.
+	(config-ml.in): Call instead of cfg-ml-pos.in.
+
+Sun Nov 12 16:44:25 1995  Per Bothner  <bothner@kalessin.cygnus.com>
+
+	* Makefile.in (VERSION):  Set to 2.7.1.
+
+Thu Nov  9 17:39:28 1995  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* config/{aix,dec-osf,irix5,linux,sol2shm}.ml: Remove LDLIBS defn;
+ 	no longer needed now that make check sets LD_LIBRARY_PATH.
+
+Wed Nov  8 19:46:35 1995  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+        * std/bastring.h: Wrap with #ifndef/#define/#endif.
+        * std/cassert.h: Likewise.
+        * std/cinst.h: Likewise.
+        * std/complext.h: Likewise.
+        * std/dcomplex.h: Likewise.
+        * std/fcomplex.h: Likewise.
+        * std/ldcomplex.h: Likewise.
+        * std/sinst.h: Likewise.
+
+Wed Nov  8 16:15:48 1995  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/bastring.cc (getline): Update to September 95 WP.  Now we
+ 	don't set failbit when reading an empty line.
+
+Tue Nov  7 16:09:04 1995  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/bastring.cc (new): Fix for sizeof (charT) != 1.
+
+Sat Nov  4 17:37:16 1995  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/complext.cc (operator / (FLOAT, const complex<FLOAT>&)):
+ 	Reimplement along the lines of the other operator / templates.
+	From John Eaton <jwe@bevo.che.wisc.edu>.
+
+Sat Nov  4 13:33:50 1995  Per Bothner  <bothner@kalessin.cygnus.com>
+
+	* configure.in (DISTCLEAN):  New, to add target-mkfrag.
+
+Tue Oct 31 13:59:32 1995  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* std/bastring.h: Use size_t for the reference count.
+	* std/bastring.cc (create): Set selfish.
+	From Joe Buck (jbuck@synopsys.com).
+
+Mon Oct 30 23:09:48 1995  Per Bothner  <bothner@kalessin.cygnus.com>
+
+	* configure.in:  Don't bother changing LIBIBERTY for cross,
+	now that we are using target-libiberty instead.
+	* Makefile.in (LIBIBERTY_DIR):  Simplify.
+	(LIBIBERTY):  Remove.
+
+Wed Oct 11 14:56:49 1995  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* config/sol2shm.ml: New files with -rpath.
+	* configure (*-*-solaris*): Use sol2shm.ml.
+
+Thu Sep 28 09:26:52 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/straits.h (compare, copy, move, set): Fix for non-char charT's.
+	* std/bastring.h (basic_string::remove): Fix for non-char charT's.
+
+Tue Sep 26 15:22:56 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* config/irix5.ml: Pass -rpath to links.
+
+Fri Sep 15 00:17:47 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* config/linux.ml: Conform to Linux shared library numbering
+ 	scheme.
+	* Makefile.in: Ditto.
+
+Tue Sep 12 00:28:56 1995  Mike Stump  <mrs@cygnus.com>
+
+	* typeinfoi.cc: (__pointer_type_info::__rtti_match): Moved from
+	the headerfile, include all sorts of pointer conversions from 15.3
+	para 2.
+	* std/typeinfo.h (__pointer_type_info::__rtti_match): Moved from here.
+
+Mon Sep 11 23:27:59 1995  Mike Stump  <mrs@cygnus.com>
+
+	* std/typeinfo.h (__pointer_type_info::__rtti_match): We no longer
+	have to dereference the object pointer, as the pointer is always
+	passed directly.
+
+Mon Sep 11 19:29:51 1995  Mike Stump  <mrs@cygnus.com>
+
+	* std/typeinfo.h (__pointer_type_info::__rtti_match): Define so
+	that pointer conversions can happen on catch type matching.
+	* typeinfoi.cc (__throw_type_match_rtti): Arrange for __rtti_match
+	to be used on pointers.
+
+Tue Sep  5 14:49:19 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* string.h: Remove for now.
+
+Thu Aug 31 14:14:01 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/bastring.cc (operator>>): Simplify and fix.
+	(resize): Fix order of arguments to append.
+	(getline): Simplify and fix.
+
+Thu Aug 24 17:44:09 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/cstdlib.h (abs): Provide default implementation for peons
+ 	without labs.
+
+Tue Aug 22 08:43:07 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/cstdlib.h: Comment out definition of div(long,long) for now,
+ 	since not all targets have ldiv.
+
+Mon Aug 21 11:46:03 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/cmath.h: Wrap abs(double) with #if ! _G_MATH_H_INLINES.
+
+	* stl.h: Add, for compatibility with ObjectSpace STL.
+
+	* std/complext.cc (operator /): Use abs instead of fabs.
+
+	* std/bastring.h (replace): Update single-character replace method
+ 	as per my proposal.
+
+	* std/cmath.h: Add abs(float), abs(double) and abs(long double).
+  	Add commented-out declarations for other float and long double
+ 	math functions.
+
+	* std/cstdlib.h: Add abs(long) and div(long,long).
+
+	* Makefile.in (install): Make shared library executable and
+ 	non-writable.  Tidy.
+	(OBJS): Add cstdlibi.o and cmathi.o.
+
+	* Rename implementation files to have different basenames.
+
+Mon Aug 21 00:57:03 1995  Jeffrey A. Law  <law@rtl.cygnus.com>
+
+	* Makefile.in (install): Use "cd stl"; no need for $(srcdir)
+	prefix because we're already in $(srcdir).
+
+Tue Jul 25 18:41:29 1995  Per Bothner  <bothner@kalessin.cygnus.com>
+
+	* std/stddef.h:  Remove obsolete definition of enum capacity.
+
+Sat Jul 22 13:37:01 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* Makefile.in (IO_DIR): Add multilib support.
+	(LIBIBERTY, LIBIBERTY_OBJS, INSTALLDIR, stdlist): Likewise.
+	(libiberty.a, install): Likewise.
+	* configure.in: Likewise.
+	(XCXXINCLUDES): Likewise.
+	* stl/configure.in: Likewise.
+	(XCXXINCLUDES): Likewise.
+
+Mon Jul 17 09:29:31 1995  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* Makefile.in (typeinfo.o, stdexcept.o): Put an else for the if
+	stmt checking PICFLAG.
+	(stmp-string, bigstmp-string, stmp-complex, bigstmp-complex): Likewise.
+
+Wed Jun 28 17:05:29 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/*.h: Wrap with extern "C++".
+
+	* std/ciso646.h: Don't worry about #undefing the keywords.
+
+Mon Jun 26 19:05:38 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/bastring.h (operator!=): If they've included the STL
+        function.h, don't overload the operator templates that it defines.
+
+Fri Jun 23 16:54:17 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* Makefile.in (SHLINK): Force link.
+	(install): Ditto.
+
+	* std/bastring.h (terminate): Never reallocate.
+	(alloc): No longer const.
+
+	* std/bastring.cc (create): Always allocate an extra byte.
+	(check_realloc): Always leave room for an extra byte.
+	(*find*): Add missing 'const'.
+
+	* Makefile.in (SHARLIB): Provide a default value.
+
+Tue Jun 20 16:29:52 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/cstring.h: Don't bother tweaking prototypes for now.  When
+        we do, we will use new-style casts.
+
+Fri Jun 16 13:57:53 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* Makefile.in (VERSION): Update to 2.7.0.
+
+	* config/aix.ml: Build both shared and archive libraries.
+
+Wed Jun 14 21:44:21 1995  Jason Merrill  <jason@python.cygnus.com>
+
+	* configure.in (frags): Use linux.ml for Linux/ELF.
+	* config/linux.ml: New file.
+
+Wed Jun 14 17:56:23 1995  Niclas Andersson  <nican@ida.liu.se>
+
+	* configure.in: Use xiberty when building cross-compiler.
+
+Wed Jun 14 12:57:47 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/*complex*, std/cinst.h, cinst.cc: Pass by reference to const
+        rather than by value.
+	* std/*complex*: Add member functions real() and imag().
+
+Sat Jun 10 12:14:38 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* Makefile.in (bigstmp-string): Call main string object cstrmain.o
+        instead of cstring.o.
+
+Wed Jun  7 11:15:15 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/cstring.h: Use #include_next to pick up <string.h>.
+
+	* string.h: New file.
+
+	* Makefile.in (MOSTLYCLEAN_JUNK): Remove piclist.
+
+	* configure.in (MOSTLYCLEAN): Remove stamp-picdir.
+
+Mon Jun  5 18:36:39 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* config/*.ml: Build both shared and archive libraries.
+
+	* configure.in (MOSTLYCLEAN): Remove pic.
+	(frags): Use toplevel pic frags.
+
+	* Makefile.in (piclist): New rule.
+	(SHLIB): Use it.
+	(stl.list): Removed.
+	(typeinfo.o): Also build pic version.
+	(stdexcept.o): Ditto.
+	(*stmp-*): Ditto.
+
+Tue May 30 12:01:14 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/{complext,{f,d,ld}complex}.h: To declare specializations,
+        use friend declarations in the class body...
+	* std/cinst.h: ...rather than macro hackery.
+
+	* Makefile.in (stdlist): Renamed from list.
+
+	* cstdarg: Don't define __CSTDARG__.
+	* complex.h: Similarly.
+
+Tue May  9 19:31:20 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/bastring.cc (operator>>): Use an int to store the return value
+        of streambuf::sbumpc.
+	(getline): Ditto.
+	* std/bastring.* (replace): Reverse size_t and charT arguments.
+
+	* configure.in (enable_shared): Support enable_shared under AIX.
+
+	* Makefile.in (SHARLIB): New variable and rule for building an
+        archive library containing a single shared object (for AIX).
+
+Mon May  8 01:43:19 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/bastring.h (remove): Forgot one.
+	(empty): And this.
+	Disable copy-on-write if someone takes an iterator.
+
+	* std/bastring.cc (getline): Avoid resizing down if unnecessary.
+	(operator>>): Don't use private methods.
+
+Sun May  7 02:39:56 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/bastring.h (insert, replace): Fix.
+	* std/bastring.cc (find_*_of): Fix.
+
+Fri May  5 01:45:10 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/bastring.h: Add iterator remove fn.  Remove evil default
+        arguments.
+
+	* std/*complex*, std/cinst.h, cinst.cc: s/__complex/complex/g.
+        complex<float> is now specialized.  Lose _*_complex in favor of
+        'explicit' constructors.
+	* std/complex.h: Lose typedef of complex.
+	* std/fcomplex.h: New file.
+	* std/complext.cc (operator<<): Accept more input forms.
+
+	* std/bastring.h: Add iterator insert fns.
+
+Thu May  4 02:30:04 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/bastring.*: Update to current draft.
+
+	* std/bastring.*: Reorganize so that the pointer in a string
+        object points to the data rather than the bsrep object, for
+        debugging.
+
+Tue Apr 25 17:15:09 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* configure.in: Update to stay in sync with config.shared.
+
+Mon Apr 24 13:08:46 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/complext.h: Declare hypot.  Declare appropriate functions const.
+
+Wed Apr 12 15:26:25 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* Makefile.in (typeinfo.o): Don't use $<.
+	(stdexcept.o): Ditto.
+
+Sat Apr  8 15:35:00 1995  Mike Stump  <mrs@cygnus.com>
+
+	* std/typeinfo.h: Move bad_cast, bad_typeid and __bad_cast_object
+	from here to stdexcept.
+	* std/stdexcept.h: Ditto.
+	* Makefile.in (stdexcept.o): Added rule to build typeinfo.o with
+	-frtti to support matching of thrown objects with rtti info for
+	bad_cast.
+
+Mon Apr  3 18:13:14 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* typeinfo: New file.
+
+	* Makefile.in (HEADERS): Add typeinfo.
+
+Mon Apr  3 15:06:58 1995  Mike Stump  <mrs@cygnus.com>
+
+	* Makefile.in (typeinfo.o): Added rule to build typeinfo.o with
+	-frtti to support matching of thrown objects with rtti info for
+	bad_cast.
+
+Wed Mar 29 15:56:06 1995  Mike Stump  <mrs@cygnus.com>
+
+	* typeinfo.cc: (__throw_type_match_rtti): Added to support
+	matching of thrown objects with rtti info.
+
+Thu Mar 23 18:42:30 1995  Jason Merrill  <jason@deneb.cygnus.com>
+
+	* Makefile.in (HEADERS): Add stdexcept.
+
+Sun Mar 12 01:25:27 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/typeinfo.h: Add return statements to dummy methods.
+
+Wed Mar  8 16:09:50 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* config/dec-osf.ml: Use -rpath flag.
+
+Fri Feb 17 18:16:46 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/typeinfo.h: Add copyright header.
+
+	* Makefile.in (CXXFLAGS): Add a bunch of warning options to keep
+        me honest.
+
+Thu Feb 16 00:04:49 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* Makefile.in, config/*.ml: Generate shared library on most hosts
+	as libstdc++.so.$(VERSION), with a symlink to libstdc++.so, so that
+	multiple versions can coexist.
+
+Fri Feb 10 02:59:39 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/exception.h: {set_,}{terminate,unexpected} have C++ linkage.
+
+	* Makefile.in: Allow string and complex to be split up either by
+        individual function or into I/O and non-I/O.  Default to the
+        latter.
+
+Wed Feb  8 02:39:47 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/bastring.h: Start thinking about throwing exceptions.
+
+	* typeinfo.cc: Remove private functions; defining them to call
+        abort () just delays errors until runtime.  Define
+        __bad_cast_object.
+
+	* std/exception.h: Standard exceptions are now defined in
+        stdexcept.h.  This header now contains declarations of terminate()
+        et al.
+	* exception.cc: Move code from libg++/src/except.c here.
+	* std/typeinfo.h: Define RTTI-related exceptions here.
+	* stdexcept{,.cc},std/stdexcept.h: New files.
+
+Mon Feb  6 18:51:31 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* Makefile.in (HEADERS): Resurrect, add new STL header names.
+	(install): Install extensionless headers again.
+	* extensionless headers: Resurrect, add new STL headers.
+        Currently only forward to std/whatever or stl/whatever.
+
+Mon Jan 30 13:53:22 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/bastring.h (basic_string (charT, size_t)): Mark explicit.
+
+	* Makefile.in (install): Set rootme when installing stl headers.
+	Only install *.* from std.
+
+Wed Jan 25 02:29:30 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* std/bastring.h (operator=): grab before releasing.
+
+Mon Jan 23 19:54:02 1995  Ronald F. Guilmette  <rfg@segfault.us.com>
+
+	* Makefile.in (install): Also install STL headers.
+
+Mon Jan 23 04:09:35 1995  Jason Merrill  <jason@python.cygnus.com>
+
+	* Makefile.in (list): Set $rootme before calling make.
+
+Wed Jan 11 19:24:47 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* typeinfo.cc (__rtti_match): Don't try to do pointer arithmetic
+        with a void *.
+
+	* move all headers into std subdirectory and update files accordingly.
+
+Thu Jan  5 01:51:49 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* bastring.ccI (basic_string (size_t, capacity)): s/reserve/::reserve/.
+
+Wed Jan  4 17:27:32 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* exception: s/string/__string/g.
+
+	* configure.in (MOSTLYCLEAN): Add so_locations.
+
+	* bastring.ccI (basic_string (size_t, capacity)): Fix thinko.
+	(various find functions): Ditto.
+
+Fri Dec 30 18:04:00 1994  Mike Stump  <mrs@cygnus.com>
+
+	* typeinfo.h: Add support for the built-in type bool.
+
+Fri Dec 30 14:57:02 1994  Mike Stump  <mrs@cygnus.com>
+
+	* typeinfo.{cc, h}: Guard against multiple inclusions, and add #p i/i.
+
+Fri Dec  2 17:56:05 1994  Mike Stump  <mrs@cygnus.com>
+
+	* libg++ 2.6.2 released.
+
+	* typeinfo.{cc, h} (__rtti_match): Change interface to compiler
+        for dynamic_casting to gear up for exception handling's use of
+        rtti for argument matching.
+
+Tue Nov 29 16:49:32 1994  Per Bothner  <bothner@kalessin.cygnus.com>
+
+	* configure.in (configdirs):  Add stl.
+	* Makefile.in:  Build stl, and merge .o files from it.
+
+Thu Nov 17 15:30:57 1994  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* bastring.hI: Add iterator, const_iterator, begin() and end() to
+        basic_string.
+
+Mon Nov  7 16:50:33 1994  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* Makefile.in, configure.in, config/*.ml, tests/Makefile.in,
+	tests/configure.in: Various changes to handle --enable-shared.
+
+Fri Nov  4 19:13:33 1994  Mike Stump  <mrs@cygnus.com>
+
+	* exception{,.cc}: Added to support catching bad_cast's.
+
+Thu Nov  3 17:42:13 1994  Mike Stump  <mrs@cygnus.com>
+
+	* typeinfo.h (type_info::{name, before}): Add to match draft.
+
+Thu Nov  3 00:56:34 1994  Jason Merrill  (jason@phydeaux.cygnus.com)
+
+	* Makefile.in (LIBIBERTY_OBJS): Add strerror.o.
+
+Mon Oct 31 15:33:06 1994  Kung Hsu  (kung@mexican.cygnus.com)
+
+	* typeinfo.cc: Fix a bug in the final return.
+	* typeinfo.cc: Fix the ANSI header version number.
+	* typeinfo.h: ditto.
+
+Fri Oct 28 14:23:12 1994  Mike Stump  <mrs@cygnus.com>
+
+	* type_info.{cc,h}: Rename to typeinfo to better match current draft.
+
+Wed Oct 26 11:13:53 1994  Kung Hsu  (kung@mexican.cygnus.com)
+
+	* type_info.h: new header file for rtti.
+	* type_info.cc: new code file for rtti.
+	* Makefile.in: change to include type_info.o in libstdc++ for rtti.
+
+Sat Oct 15 16:09:51 1994  Jason Merrill  (jason@phydeaux.cygnus.com)
+
+	* libg++ 2.6.1 released.
+
+	* cinst.hI: Also declare instantiations of out-of-line functions.
+
+Fri Oct 14 15:00:09 1994  Jason Merrill  (jason@phydeaux.cygnus.com)
+
+	* configure.in (CXXINCLUDES): Use {} to wrap variable name.
+	* tests/configure.in (CXXINCLUDES): Ditto.
+
+	* cinst.hI: Declare instantiations of two-argument functions so
+        overload resolution will work.
+	* complext.hI: Always include cinst.hI.
+
+	* bastring.ccI (operator>>): Tweak.
+
+Tue Oct 11 17:07:49 1994  Jason Merrill  (jason@phydeaux.cygnus.com)
+
+	* stddef*: Do the #pragma i/i thang.
+
+	* bastring.hI (basic_string::put_at): Use operator[].
+	(basic_string::terminate): Don't necessarily copy the rep.
+
+	* bastring.ccI (operator>>): Avoid shrinking and then re-expanding
+        the string.
+
+	* bastring.*I, sinst.cc: Only allow allocation policy control if
+	_G_ALLOC_CONTROL is defined.
+
+	* Makefile.in (libstdc++.a): Depend on iostream.list and libiberty.a.
+	(../libio/iostream.list): New rule.
+	(../libiberty/libiberty.a): New rule.
+	(OBJS): Add stddef.o.
+
+Sat Oct  8 23:59:45 1994  Jason Merrill (jason@phydeaux.cygnus.com)
+
+	* *: First checkin.
diff --git a/gnu/egcs/libstdc++/Makefile.in b/gnu/egcs/libstdc++/Makefile.in
new file mode 100644
index 00000000000..9e03d0545a7
--- /dev/null
+++ b/gnu/egcs/libstdc++/Makefile.in
@@ -0,0 +1,383 @@
+# Copyright (C) 1994, 1995 Free Software Foundation
+
+# This file is part of the GNU ANSI 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, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+VERSION = 2.9.0
+INTERFACE = 2
+
+gxx_include_dir=${includedir}/g++
+
+OBJS  = cstringi.o stdexcepti.o cstdlibi.o cmathi.o stlinst.o
+SUBLIBS = $(STAMP)-string $(STAMP)-complx
+
+# C++ headers with no extension
+HEADERS= cassert cctype cerrno cfloat ciso646 climits clocale cmath complex \
+	 csetjmp csignal cstdarg cstddef cstdio cstdlib cstring ctime \
+	 cwchar cwctype string stdexcept \
+	 algorithm deque functional hash_map hash_set iterator list map \
+	 memory numeric pthread_alloc queue rope set slist stack utility \
+	 vector fstream iomanip iostream strstream iosfwd bitset
+
+ARLIB   = libstdc++.a.$(VERSION)
+ARLINK  = libstdc++.a
+MARLINK = libstdc++.a.`echo $(VERSION) | sed 's/\([0-9][.][0-9]\).*/\1/'`
+SHLIB   = libstdc++.so.$(VERSION)
+SHARLIB = libstdc++-sh.a
+SHLINK  = libstdc++.so
+MSHLINK = libstdc++.so.`echo $(VERSION) | sed 's/\([0-9][.][0-9]\).*/\1/'`
+SHFLAGS =
+SHDEPS  =
+
+STAMP   = bigstmp
+
+LIBS    = $(ARLIB) $(ARLINK)
+
+#### package, host, target, and site dependent Makefile fragments come in here.
+##
+
+IO_DIR    = ../libio
+LIBIBERTY_DIR = ../libiberty
+
+LIBIBERTY_OBJS = `cat $(LIBIBERTY_DIR)/needed-list` strerror.o
+
+tooldir = $(exec_prefix)/$(target)
+# This is where the libraries will be installed; note, it will be set
+# at make runtime now. See below at target install.
+INSTALLDIR = $(libdir)
+
+MOSTLYCLEAN_JUNK = *stmp-* tlib*.a *.s *.ii stdlist piclist
+CLEAN_JUNK = $(LIBS)
+
+.PHONY: libs
+libs: $(LIBS)
+
+stdlist: $(IO_DIR)/iostream.list $(OBJS) $(SUBLIBS) $(LIBIBERTY_DIR)/libiberty.a
+	-rm -f tlist
+	touch tlist
+	echo *.o >> tlist
+	for f in `cat $(IO_DIR)/iostream.list` ; do \
+	  echo "$(IO_DIR)/$$f" >> tlist ; \
+	done
+	for f in $(LIBIBERTY_OBJS) ; do \
+	  echo "$(LIBIBERTY_DIR)/$$f" >> tlist ; \
+	done
+	mv tlist stdlist
+
+piclist: stdlist
+	-rm -f tlist
+	cp stdlist tlist
+	if [ x"$(enable_shared)" = xyes ]; then \
+	  sed 's,\([A-Za-z_]*\.o\),pic/\1,g' tlist > tlist2 ; \
+	  mv tlist2 tlist ; \
+	else true ; fi
+	mv tlist piclist
+
+$(ARLIB): stdlist
+	-rm -f t$(ARLIB)
+	$(AR) $(AR_FLAGS) t$(ARLIB) `cat stdlist`
+	mv t$(ARLIB) $(ARLIB)
+	$(RANLIB) $(ARLIB)
+
+$(ARLINK):
+	-rm -f $(ARLINK)
+	$(LN_S) $(ARLIB) $(ARLINK) || cp $(ARLIB) $(ARLINK)
+
+marlink:
+	@$(MAKE) $(MARLINK) "ARLINK=$(MARLINK)"
+
+$(SHLIB): piclist
+	$(CC) $(LIBCXXFLAGS) $(SHFLAGS) -shared -o $(SHLIB) `cat piclist` $(SHDEPS)
+
+$(SHARLIB): $(SHLIB)
+	-rm -f t$(SHARLIB)
+	$(AR) $(AR_FLAGS) t$(SHARLIB) $(SHLIB)
+	mv t$(SHARLIB) $(SHARLIB)
+	$(RANLIB) $(SHARLIB)
+
+$(SHLINK):
+	-rm -f $(SHLINK)
+	$(LN_S) $(SHLIB) $(SHLINK) || cp $(ARLIB) $(ARLINK)
+
+mshlink:
+	@$(MAKE) $(MSHLINK) "SHLINK=$(MSHLINK)"
+
+$(IO_DIR)/iostream.list: force
+	cd $(IO_DIR) ; $(MAKE) $(FLAGS_TO_PASS) iostream.list
+
+$(LIBIBERTY_DIR)/libiberty.a:
+	cd $(LIBIBERTY_DIR) ; $(MAKE) $(FLAGS_TO_PASS)
+
+STRFUNCS = REP MAIN TRAITS ADDSS ADDPS ADDCS ADDSP ADDSC \
+	   EQSS EQPS EQSP NESS NEPS NESP LTSS LTPS LTSP GTSS GTPS GTSP \
+	   LESS LEPS LESP GESS GEPS GESP
+STRIO	 = EXTRACT INSERT GETLINE
+
+# These are here for SunOS VPATH.
+cstringi.o: cstringi.cc
+cstdlibi.o: cstdlibi.cc
+cmathi.o: cmathi.cc
+stdexcepti.o: stdexcepti.cc
+stlinst.o: stlinst.cc
+
+# Later do wide strings, too.
+stmp-string: ${srcdir}/sinst.cc ${srcdir}/std/bastring.h \
+	     ${srcdir}/std/bastring.cc ${srcdir}/std/straits.h
+	for name in $(STRFUNCS) $(STRIO); do \
+	  echo c$${name}; \
+	  if [ x"$(enable_shared)" = xyes ]; then \
+	    $(COMPILE.cc) $(PICFLAG) -DC -D$${name} ${srcdir}/sinst.cc \
+	      -o pic/c$${name}.o; \
+	  else true ; fi; \
+	  if [ $$? -eq 0 ]; then true; else exit 1; fi; \
+	  $(COMPILE.cc) -DC -D$${name} ${srcdir}/sinst.cc -o c$${name}.o; \
+	  if [ $$? -eq 0 ]; then true; else exit 1; fi; \
+	done
+	touch stmp-string
+
+bigstmp-string: ${srcdir}/sinst.cc ${srcdir}/std/bastring.h \
+	        ${srcdir}/std/bastring.cc ${srcdir}/std/straits.h
+	echo cstring
+	if [ x"$(enable_shared)" = xyes ]; then \
+	  $(COMPILE.cc) $(PICFLAG) -DC \
+	    `for N in $(STRFUNCS); do echo " -D$${N}"; done` \
+	    $(srcdir)/sinst.cc -o pic/cstrmain.o; \
+	else true ; fi
+	$(COMPILE.cc) -DC `for N in $(STRFUNCS); do echo " -D$${N}"; done` \
+	  $(srcdir)/sinst.cc -o cstrmain.o
+	echo cstrio
+	if [ x"$(enable_shared)" = xyes ]; then \
+	  $(COMPILE.cc) $(PICFLAG) -DC \
+	    `for N in $(STRIO); do echo " -D$${N}"; done` \
+	    $(srcdir)/sinst.cc -o pic/cstrio.o; \
+	else true ; fi
+	$(COMPILE.cc) -DC `for N in $(STRIO); do echo " -D$${N}"; done` \
+	  $(srcdir)/sinst.cc -o cstrio.o
+	touch bigstmp-string
+
+COMFUNCS = MAIN ADDCC ADDCF ADDFC SUBCC SUBCF SUBFC MULCC MULCF MULFC DIVCC \
+	   DIVCF DIVFC PLUS MINUS EQCC EQCF EQFC NECC NECF NEFC ABS ARG POLAR \
+	   CONJ NORM COS COSH EXP LOG POWCC POWCF POWCI POWFC SIN SINH SQRT
+COMIO    = EXTRACT INSERT
+
+stmp-complx: ${srcdir}/cinst.cc ${srcdir}/std/complext.h \
+	      ${srcdir}/std/complext.cc ${srcdir}/std/dcomplex.h \
+	      ${srcdir}/std/ldcomplex.h
+	for N in $(COMFUNCS) $(COMIO); do \
+	  echo f$${N}; \
+	  if [ x"$(enable_shared)" = xyes ]; then \
+	    $(COMPILE.cc) $(PICFLAG) -DF -D$${N} $(srcdir)/cinst.cc \
+	      -o pic/f$${N}.o; \
+	  else true ; fi; \
+	  if [ $$? -eq 0 ]; then true; else exit 1; fi; \
+	  $(COMPILE.cc) -DF -D$${N} ${srcdir}/cinst.cc -o f$${N}.o; \
+	  if [ $$? -eq 0 ]; then true; else exit 1; fi; \
+	  echo d$${N}; \
+	  if [ x"$(enable_shared)" = xyes ]; then \
+	    $(COMPILE.cc) $(PICFLAG) -DD -D$${N} $(srcdir)/cinst.cc \
+	      -o pic/d$${N}.o; \
+	  else true ; fi; \
+	  if [ $$? -eq 0 ]; then true; else exit 1; fi; \
+	  $(COMPILE.cc) -DD -D$${N} ${srcdir}/cinst.cc -o d$${N}.o; \
+	  if [ $$? -eq 0 ]; then true; else exit 1; fi; \
+	  echo ld$${N}; \
+	  if [ x"$(enable_shared)" = xyes ]; then \
+	    $(COMPILE.cc) $(PICFLAG) -DLD -D$${N} $(srcdir)/cinst.cc \
+	      -o pic/ld$${N}.o; \
+	  else true ; fi; \
+	  if [ $$? -eq 0 ]; then true; else exit 1; fi; \
+	  $(COMPILE.cc) -DLD -D$${N} ${srcdir}/cinst.cc -o ld$${N}.o; \
+	  if [ $$? -eq 0 ]; then true; else exit 1; fi; \
+	done
+	touch stmp-complx
+
+bigstmp-complx: ${srcdir}/cinst.cc ${srcdir}/std/complext.h \
+	         ${srcdir}/std/complext.cc ${srcdir}/std/dcomplex.h \
+	         ${srcdir}/std/ldcomplex.h
+	echo fcomplex
+	if [ x"$(enable_shared)" = xyes ]; then \
+	  $(COMPILE.cc) $(PICFLAG) -DF \
+	    `for N in $(COMFUNCS); do echo " -D$${N}"; done` \
+	    $(srcdir)/cinst.cc -o pic/fcomplex.o; \
+	else true ; fi
+	$(COMPILE.cc) -DF `for N in $(COMFUNCS); do echo " -D$${N}"; done` \
+	  $(srcdir)/cinst.cc -o fcomplex.o
+	echo fcomio
+	if [ x"$(enable_shared)" = xyes ]; then \
+	  $(COMPILE.cc) $(PICFLAG) -DF \
+	    `for N in $(COMIO); do echo " -D$${N}"; done` \
+	    $(srcdir)/cinst.cc -o pic/fcomio.o; \
+	else true ; fi
+	$(COMPILE.cc) -DF `for N in $(COMIO); do echo " -D$${N}"; done` \
+	  $(srcdir)/cinst.cc -o fcomio.o
+	echo dcomplex
+	if [ x"$(enable_shared)" = xyes ]; then \
+	  $(COMPILE.cc) $(PICFLAG) -DD \
+	    `for N in $(COMFUNCS); do echo " -D$${N}"; done` \
+	    $(srcdir)/cinst.cc -o pic/dcomplex.o; \
+	else true ; fi
+	$(COMPILE.cc) -DD `for N in $(COMFUNCS); do echo " -D$${N}"; done` \
+	  $(srcdir)/cinst.cc -o dcomplex.o
+	echo dcomio
+	if [ x"$(enable_shared)" = xyes ]; then \
+	  $(COMPILE.cc) $(PICFLAG) -DD \
+	    `for N in $(COMIO); do echo " -D$${N}"; done` \
+	    $(srcdir)/cinst.cc -o pic/dcomio.o; \
+	else true ; fi
+	$(COMPILE.cc) -DD `for N in $(COMIO); do echo " -D$${N}"; done` \
+	  $(srcdir)/cinst.cc -o dcomio.o
+	echo ldcomplex
+	if [ x"$(enable_shared)" = xyes ]; then \
+	  $(COMPILE.cc) $(PICFLAG) -DLD \
+	    `for N in $(COMFUNCS); do echo " -D$${N}"; done` \
+	    $(srcdir)/cinst.cc -o pic/ldcomplex.o; \
+	else true ; fi
+	$(COMPILE.cc) -DLD `for N in $(COMFUNCS); do echo " -D$${N}"; done` \
+	  $(srcdir)/cinst.cc -o ldcomplex.o
+	echo ldcomio
+	if [ x"$(enable_shared)" = xyes ]; then \
+	  $(COMPILE.cc) $(PICFLAG) -DLD \
+	    `for N in $(COMIO); do echo " -D$${N}"; done` \
+	    $(srcdir)/cinst.cc -o pic/ldcomio.o; \
+	else true ; fi
+	$(COMPILE.cc) -DLD `for N in $(COMIO); do echo " -D$${N}"; done` \
+	  $(srcdir)/cinst.cc -o ldcomio.o
+	touch bigstmp-complx
+
+.PHONY: install
+install:
+	rootme=`pwd`/ ; export rootme ; \
+	if [ -z "$(MULTISUBDIR)" ]; then \
+	  cd $(srcdir); \
+	  for FILE in $(HEADERS); do \
+	    rm -f $(gxx_include_dir)/$$FILE ; \
+	    if [ -f stl/$$FILE ]; then \
+	      $(INSTALL_DATA) stl/$$FILE $(gxx_include_dir)/$$FILE ; \
+	    else \
+	      $(INSTALL_DATA) $$FILE $(gxx_include_dir)/$$FILE ; \
+	    fi ; \
+	    chmod a-x $(gxx_include_dir)/$$FILE ; \
+	  done ; \
+	  for FILE in *.h std/*.h std/*.cc; do \
+	    rm -f $(gxx_include_dir)/$$FILE ; \
+	    $(INSTALL_DATA) $$FILE $(gxx_include_dir)/$$FILE ; \
+	    chmod a-x $(gxx_include_dir)/$$FILE ; \
+	  done ; \
+	  cd stl; \
+	  for FILE in *.h; do \
+	    rm -f $(gxx_include_dir)/$$FILE ; \
+	    $(INSTALL_DATA) $$FILE $(gxx_include_dir)/$$FILE ; \
+	    chmod a-x $(gxx_include_dir)/$$FILE ; \
+	  done ; \
+	else true ; \
+	fi
+	rootme=`pwd`/ ; export rootme ; \
+	if [ x$(enable_version_specific_runtime_libs) != xyes ]; then \
+	  INSTALLDIR=$(libdir); \
+	else \
+	  INSTALLDIR=$(libsubdir); \
+	fi; \
+	INSTALLLINKDIR=$(libsubdir); \
+	if [ $${INSTALLLINKDIR}$(MULTISUBDIR) = $${INSTALLDIR}$(MULTISUBDIR) ]; then \
+	  RELINSTALLDIR=; \
+	elif [ x$(MULTISUBDIR) = x ]; then \
+	  if [ $(build_alias) = $(target_alias) ]; then \
+	    RELINSTALLDIR=../../../; \
+	  else \
+	    RELINSTALLDIR=../../../../$(target_alias)/lib/; \
+	  fi; \
+	else \
+	  if [ $(build_alias) = $(target_alias) ]; then \
+	    RELINSTALLDIR=../../..`echo $(MULTISUBDIR) | sed -e 's,/[^/]*,/..,g'`$(MULTISUBDIR)/; \
+	  else \
+	    RELINSTALLDIR=../../../..`echo $(MULTISUBDIR) | sed -e 's,/[^/]*,/..,g'`/$(target_alias)/lib$(MULTISUBDIR)/; \
+	  fi; \
+	fi; \
+	if [ $(build_alias) != $(target_alias) ]; then \
+	  case $$RELINSTALLDIR in \
+	  ../../../|../../../../) \
+	    RELINSTALLDIR=../$${RELINSTALLDIR}$(target_alias)/lib/;; \
+	  esac; \
+	fi; \
+	rm -f $${INSTALLLINKDIR}$(MULTISUBDIR)/$(SHLINK) ; \
+	rm -f $${INSTALLLINKDIR}$(MULTISUBDIR)/$(ARLINK) ; \
+	for FILE in $(LIBS) ; do \
+	  rm -f $${INSTALLDIR}$(MULTISUBDIR)/$$FILE ; \
+	  if [ $$FILE = $(SHLINK) ] ; then \
+	    if [ -f $${INSTALLDIR}/$(MSHLINK) ]; then \
+	      rm -f $${INSTALLLINKDIR}$(MULTISUBDIR)/$$FILE ; \
+	      $(LN_S) $${RELINSTALLDIR}$(MSHLINK) $${INSTALLLINKDIR}$(MULTISUBDIR)/$$FILE \
+		|| cp $${RELINSTALLDIR}$(MSHLINK) $${INSTALLLINKDIR}$(MULTISUBDIR)/$$FILE ; \
+	    else \
+	      rm -f $${INSTALLLINKDIR}$(MULTISUBDIR)/$$FILE ; \
+	      $(LN_S) $${RELINSTALLDIR}$(SHLIB) $${INSTALLLINKDIR}$(MULTISUBDIR)/$$FILE \
+		|| cp $${RELINSTALLDIR}$(SHLIB) $${INSTALLLINKDIR}$(MULTISUBDIR)/$$FILE ; \
+	    fi; \
+	  elif [ $$FILE = $(ARLINK) ] ; then \
+	    if [ -f $${INSTALLDIR}/$(MARLINK) ]; then \
+	      rm -f $${INSTALLLINKDIR}$(MULTISUBDIR)/$$FILE ; \
+	      $(LN_S) $${RELINSTALLDIR}$(MARLINK) $${INSTALLLINKDIR}$(MULTISUBDIR)/$$FILE \
+		|| cp $${RELINSTALLDIR}$(MARLINK) $${INSTALLLINKDIR}$(MULTISUBDIR)/$$FILE ; \
+	    else \
+	      rm -f $${INSTALLLINKDIR}$(MULTISUBDIR)/$$FILE ; \
+	      $(LN_S) $${RELINSTALLDIR}$(ARLIB) $${INSTALLLINKDIR}$(MULTISUBDIR)/$$FILE \
+		|| cp $${RELINSTALLDIR}$(ARLIB) $${INSTALLLINKDIR}$(MULTISUBDIR)/$$FILE ; \
+	    fi; \
+	  elif [ $$FILE = mshlink ]; then \
+	    for FILE in $(MSHLINK) ; do \
+	      rm -f $${INSTALLDIR}$(MULTISUBDIR)/$$FILE ; \
+	      $(LN_S) $(SHLIB) $${INSTALLDIR}$(MULTISUBDIR)/$$FILE \
+		|| cp $(SHLIB) $${INSTALLDIR}$(MULTISUBDIR)/$$FILE ; \
+	    done; \
+	  elif [ $$FILE = marlink ]; then \
+	    for FILE in $(MARLINK) ; do \
+	      rm -f $${INSTALLDIR}$(MULTISUBDIR)/$$FILE ; \
+	      $(LN_S) $(ARLIB) $${INSTALLDIR}$(MULTISUBDIR)/$$FILE \
+		|| cp $(ARLIB) $${INSTALLDIR}$(MULTISUBDIR)/$$FILE ; \
+	    done; \
+	  elif [ $$FILE = $(SHLIB) ]; then \
+	    $(INSTALL_PROGRAM) $$FILE $${INSTALLDIR}$(MULTISUBDIR)/$$FILE ; \
+	    : On the HP, shared libraries must be mode 555. ;\
+	    chmod 555 $${INSTALLDIR}$(MULTISUBDIR)/$$FILE ; \
+	  else \
+	    $(INSTALL_DATA) $$FILE $${INSTALLDIR}$(MULTISUBDIR)/$$FILE ; \
+	    $(RANLIB) $${INSTALLDIR}$(MULTISUBDIR)/$$FILE ; \
+	    chmod a-x $${INSTALLDIR}$(MULTISUBDIR)/$$FILE ; \
+	  fi ; \
+	done
+	@rootme=`pwd`/ ; export rootme ; \
+	$(MULTIDO) $(FLAGS_TO_PASS) multi-do DO=install
+
+.PHONY: force
+force:
+
+MYCXXFLAGS = -g -O2 -Wpointer-arith -Wnested-externs -Woverloaded-virtual -Wbad-function-cast -Winline -Wwrite-strings -pedantic -Wno-long-long
+MYCFLAGS = -g -O2 -Wpointer-arith -Wnested-externs
+
+.PHONY: stuff
+stuff:
+	$(MAKE) stuff1
+	$(MAKE) stuff2
+
+stuff1:
+	$(MAKE) clean
+	$(MAKE) -C ../libio c++clean
+	touch ../../gcc/libgcc2.ready
+
+stuff2:
+	$(MAKE) -C ../../gcc/ libgcc.a
+	$(MAKE) CXXFLAGS="$(MYCXXFLAGS)" CFLAGS="$(MYCFLAGS)"
+	-$(MAKE) check
+	-$(MAKE) -C ../libio check
+	-$(MAKE) -C ../../gcc check-g++
diff --git a/gnu/egcs/libstdc++/NEWS b/gnu/egcs/libstdc++/NEWS
new file mode 100644
index 00000000000..89e866e7d3f
--- /dev/null
+++ b/gnu/egcs/libstdc++/NEWS
@@ -0,0 +1,9 @@
+SUMMARY OF RECENT MAJOR CHANGES to LIBSTDC++.
+(Also check ../libio/NEWS.)
+
+*** Noteworthy changes in libstdc++ for EGCS
+
+* EGCS includes the SGI STL implementation without changes.
+
+* As a result of these and other changes, libstc++ for EGCS is not binary
+  compatible with previous releases of libstdc++.
diff --git a/gnu/egcs/libstdc++/cassert b/gnu/egcs/libstdc++/cassert
new file mode 100644
index 00000000000..b4165bfae7f
--- /dev/null
+++ b/gnu/egcs/libstdc++/cassert
@@ -0,0 +1,7 @@
+// -*- C++ -*- forwarding header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __CASSERT__
+#define __CASSERT__
+#include <assert.h>
+#endif
diff --git a/gnu/egcs/libstdc++/cctype b/gnu/egcs/libstdc++/cctype
new file mode 100644
index 00000000000..e2765aed50a
--- /dev/null
+++ b/gnu/egcs/libstdc++/cctype
@@ -0,0 +1,7 @@
+// The -*- C++ -*- character type header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __CCTYPE__
+#define __CCTYPE__
+#include <ctype.h>
+#endif
diff --git a/gnu/egcs/libstdc++/cerrno b/gnu/egcs/libstdc++/cerrno
new file mode 100644
index 00000000000..ce493469597
--- /dev/null
+++ b/gnu/egcs/libstdc++/cerrno
@@ -0,0 +1,7 @@
+// The -*- C++ -*- error number header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __CERRNO__
+#define __CERRNO__
+#include <errno.h>
+#endif
diff --git a/gnu/egcs/libstdc++/cfloat b/gnu/egcs/libstdc++/cfloat
new file mode 100644
index 00000000000..cf59eadfb79
--- /dev/null
+++ b/gnu/egcs/libstdc++/cfloat
@@ -0,0 +1,7 @@
+// -*- C++ -*- forwarding header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __CFLOAT__
+#define __CFLOAT__
+#include <float.h>
+#endif
diff --git a/gnu/egcs/libstdc++/cinst.cc b/gnu/egcs/libstdc++/cinst.cc
new file mode 100644
index 00000000000..983e8a9caa7
--- /dev/null
+++ b/gnu/egcs/libstdc++/cinst.cc
@@ -0,0 +1,154 @@
+// Instantiation file for the -*- C++ -*- complex number classes.
+// Copyright (C) 1994 Free Software Foundation
+
+#ifdef F
+typedef float f;
+#endif
+#ifdef D
+typedef double f;
+#endif
+#ifdef LD
+typedef long double f;
+#endif
+
+#if defined (MAIN) && defined (__GNUG__)
+#ifdef F
+#pragma implementation "fcomplex"
+#endif
+#ifdef D
+#pragma implementation "dcomplex"
+#endif
+#ifdef LD
+#pragma implementation "ldcomplex"
+#endif
+#endif
+
+#if 0
+#define _G_NO_EXTERN_TEMPLATES
+#endif
+#include <std/complext.cc>
+
+typedef complex<f> c;
+typedef const c& ccr;
+
+#ifdef MAIN
+template c& __doapl (c*, ccr);
+template c& __doaml (c*, ccr);
+template c& __doami (c*, ccr);
+template c& __doadv (c*, ccr);
+#endif
+
+#ifdef ADDCC
+template c operator+ (ccr, ccr);
+#endif
+#ifdef ADDCF
+template c operator+ (ccr, f);
+#endif
+#ifdef ADDFC
+template c operator+ (f, ccr);
+#endif
+#ifdef SUBCC
+template c operator- (ccr, ccr);
+#endif
+#ifdef SUBCF
+template c operator- (ccr, f);
+#endif
+#ifdef SUBFC
+template c operator- (f, ccr);
+#endif
+#ifdef MULCC
+template c operator* (ccr, ccr);
+#endif
+#ifdef MULCF
+template c operator* (ccr, f);
+#endif
+#ifdef MULFC
+template c operator* (f, ccr);
+#endif
+#ifdef DIVCC
+template c operator/ (ccr, ccr);
+#endif
+#ifdef DIVCF
+template c operator/ (ccr, f);
+#endif
+#ifdef DIVFC
+template c operator/ (f, ccr);
+#endif
+#ifdef PLUS
+template c operator+ (ccr);
+#endif
+#ifdef MINUS
+template c operator- (ccr);
+#endif
+#ifdef EQCC
+template bool operator== (ccr, ccr);
+#endif
+#ifdef EQCF
+template bool operator== (ccr, f);
+#endif
+#ifdef EQFC
+template bool operator== (f, ccr);
+#endif
+#ifdef NECC
+template bool operator!= (ccr, ccr);
+#endif
+#ifdef NECF
+template bool operator!= (ccr, f);
+#endif
+#ifdef NEFC
+template bool operator!= (f, ccr);
+#endif
+#ifdef ABS
+template f abs (ccr);
+#endif
+#ifdef ARG
+template f arg (ccr);
+#endif
+#ifdef POLAR
+template c polar (f, f);
+#endif
+#ifdef CONJ
+template c conj (ccr);
+#endif
+#ifdef NORM
+template f norm (ccr);
+#endif
+#ifdef COS
+template c cos (ccr);
+#endif
+#ifdef COSH
+template c cosh (ccr);
+#endif
+#ifdef EXP
+template c exp (ccr);
+#endif
+#ifdef LOG
+template c log (ccr);
+#endif
+#ifdef POWCC
+template c pow (ccr, ccr);
+#endif
+#ifdef POWCF
+template c pow (ccr, f);
+#endif
+#ifdef POWCI
+template c pow (ccr, int);
+#endif
+#ifdef POWFC
+template c pow (f, ccr);
+#endif
+#ifdef SIN
+template c sin (ccr);
+#endif
+#ifdef SINH
+template c sinh (ccr);
+#endif
+#ifdef SQRT
+template c sqrt (ccr);
+#endif
+#ifdef EXTRACT
+template istream& operator>> (istream&, complex<f>&);
+#endif
+#ifdef INSERT
+template ostream& operator<< (ostream&, const complex<f>&);
+#endif
diff --git a/gnu/egcs/libstdc++/ciso646 b/gnu/egcs/libstdc++/ciso646
new file mode 100644
index 00000000000..4d8200d73dc
--- /dev/null
+++ b/gnu/egcs/libstdc++/ciso646
@@ -0,0 +1,7 @@
+// -*- C++ -*- forwarding header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __CISO646__
+#define __CISO646__
+#include <iso646.h>
+#endif
diff --git a/gnu/egcs/libstdc++/climits b/gnu/egcs/libstdc++/climits
new file mode 100644
index 00000000000..1b29b3af01e
--- /dev/null
+++ b/gnu/egcs/libstdc++/climits
@@ -0,0 +1,7 @@
+// -*- C++ -*- forwarding header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __CLIMITS__
+#define __CLIMITS__
+#include <limits.h>
+#endif
diff --git a/gnu/egcs/libstdc++/clocale b/gnu/egcs/libstdc++/clocale
new file mode 100644
index 00000000000..b67cf31c9d2
--- /dev/null
+++ b/gnu/egcs/libstdc++/clocale
@@ -0,0 +1,7 @@
+// The -*- C++ -*- locale support header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __CLOCALE__
+#define __CLOCALE__
+#include <locale.h>
+#endif
diff --git a/gnu/egcs/libstdc++/cmath b/gnu/egcs/libstdc++/cmath
new file mode 100644
index 00000000000..b18ea0b428c
--- /dev/null
+++ b/gnu/egcs/libstdc++/cmath
@@ -0,0 +1,76 @@
+// The -*- C++ -*- math functions header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __CMATH__
+#define __CMATH__
+#include <_G_config.h>
+#include <math.h>
+
+#ifdef __GNUG__
+#pragma interface "cmath"
+#endif
+
+extern "C++" {
+#if 0
+float acos (float);
+float asin (float);
+float atan (float);
+float atan2(float, float);
+float ceil (float);
+float cos  (float);
+float cosh (float);
+float exp  (float);
+float fabs (float);
+float floor(float);
+float fmod (float, float);
+float frexp(float, int*);
+float modf (float, float*);
+float ldexp(float, int);
+float log  (float);
+float log10(float);
+float pow  (float, float);
+float pow  (float, int);
+float sin  (float);
+float sinh (float);
+float sqrt (float);
+float tan  (float);
+float tanh (float);
+#endif
+
+inline float  abs (float  x) { return fabs (x); }
+#if ! _G_MATH_H_INLINES /* hpux and SCO define this in math.h */
+inline double abs (double x) { return fabs (x); }
+#endif
+
+#if 0
+double pow(double, int);
+
+long double acos (long double);
+long double asin (long double);
+long double atan (long double);
+long double atan2(long double, long double);
+long double ceil (long double);
+long double cos  (long double);
+long double cosh (long double);
+long double exp  (long double);
+long double fabs (long double);
+long double floor(long double);
+long double frexp(long double, int*);
+long double fmod (long double, long double);
+long double frexp(long double, int*);
+long double log  (long double);
+long double log10(long double);
+long double modf (long double, long double*);
+long double pow  (long double, long double);
+long double pow  (long double, int);
+long double sin  (long double);
+long double sinh (long double);
+long double sqrt (long double);
+long double tan  (long double);
+long double tanh (long double);
+#endif
+inline long double abs (long double x) { return fabs (x); }
+
+} // extern "C++"
+
+#endif
diff --git a/gnu/egcs/libstdc++/cmathi.cc b/gnu/egcs/libstdc++/cmathi.cc
new file mode 100644
index 00000000000..afd740f013e
--- /dev/null
+++ b/gnu/egcs/libstdc++/cmathi.cc
@@ -0,0 +1,7 @@
+// Implementation file for the -*- C++ -*- math functions header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifdef __GNUG__
+#pragma implementation "cmath"
+#endif
+#include <cmath>
diff --git a/gnu/egcs/libstdc++/complex b/gnu/egcs/libstdc++/complex
new file mode 100644
index 00000000000..bfdd352b462
--- /dev/null
+++ b/gnu/egcs/libstdc++/complex
@@ -0,0 +1,18 @@
+// Main header for the -*- C++ -*- complex number classes.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __COMPLEX__
+#define __COMPLEX__
+
+#include <std/complext.h>
+
+extern "C++" {
+#define __STD_COMPLEX
+
+// ANSI complex types
+typedef complex<float> float_complex;
+typedef complex<double> double_complex;
+typedef complex<long double> long_double_complex;
+}
+
+#endif
diff --git a/gnu/egcs/libstdc++/complex.h b/gnu/egcs/libstdc++/complex.h
new file mode 100644
index 00000000000..2e88de854a6
--- /dev/null
+++ b/gnu/egcs/libstdc++/complex.h
@@ -0,0 +1,6 @@
+// -*- C++ -*- backward compatiblity header.
+// Copyright (C) 1994 Free Software Foundation
+
+#ifndef __COMPLEX_H__
+#include <complex>
+#endif
diff --git a/gnu/egcs/libstdc++/config/aix.ml b/gnu/egcs/libstdc++/config/aix.ml
new file mode 100644
index 00000000000..dec7a905a34
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/aix.ml
@@ -0,0 +1,9 @@
+# AIX has wierd shared/non-shared libraries.
+
+ARLIB	 = libstdc++-ar.a.$(VERSION)
+ARLINK	 = libstdc++-ar.a
+SHLINK   = libstdc++.a
+LIBS     = $(ARLIB) $(ARLINK) $(SHLIB) $(SHLINK)
+DEPLIBS  = ../$(SHLIB)
+SHDEPS   = -lm
+SHFLAGS  = -Wl,-unix
diff --git a/gnu/egcs/libstdc++/config/dec-osf.ml b/gnu/egcs/libstdc++/config/dec-osf.ml
new file mode 100644
index 00000000000..a11f373d84c
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/dec-osf.ml
@@ -0,0 +1,6 @@
+# We don't need -fpic on the alpha, so let's install both the shared and
+# non-shared versions.
+
+LIBS     = $(ARLIB) $(ARLINK) $(SHLIB) $(SHLINK)
+DEPLIBS  = ../$(SHLIB)
+SHDEPS   = -lm
diff --git a/gnu/egcs/libstdc++/config/delta.mt b/gnu/egcs/libstdc++/config/delta.mt
new file mode 100644
index 00000000000..b0b36db1062
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/delta.mt
@@ -0,0 +1,2 @@
+# If FPU instructions are generated by default, we have to use a special libm.a
+MLDLIBS = $(LDLIBS) `case "$(CXXFLAGS)" in *-m68000* | *-mc68000* | *-msoft-float* ) echo -lm ;; * ) echo -lm881 ;; esac`
diff --git a/gnu/egcs/libstdc++/config/elf.ml b/gnu/egcs/libstdc++/config/elf.ml
new file mode 100644
index 00000000000..bd711debf83
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/elf.ml
@@ -0,0 +1,8 @@
+# Elf without shared libm -- we have to link with the archive library, even
+# for programs that don't use complex.
+
+LIBS    = $(ARLIB) $(ARLINK) $(SHLIB) $(SHLINK)
+SHFLAGS = -h $(SHLIB)
+DEPLIBS = ../$(SHLIB)
+LDLIBS  = -L.. -lstdc++ -lm
+MLDLIBS = -L.. -lstdc++ -lm
diff --git a/gnu/egcs/libstdc++/config/elfshlibm.ml b/gnu/egcs/libstdc++/config/elfshlibm.ml
new file mode 100644
index 00000000000..826f0bc0917
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/elfshlibm.ml
@@ -0,0 +1,6 @@
+# Elf with shared libm, so we can link it into the shared libstdc++.
+
+LIBS    = $(ARLIB) $(ARLINK) $(SHLIB) $(SHLINK)
+SHFLAGS = -h $(SHLIB)
+SHDEPS  = -lm
+DEPLIBS = ../$(SHLIB)
diff --git a/gnu/egcs/libstdc++/config/freebsd.ml b/gnu/egcs/libstdc++/config/freebsd.ml
new file mode 100644
index 00000000000..3ee682690ad
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/freebsd.ml
@@ -0,0 +1,6 @@
+# Elf with shared libm, so we can link it into the shared libstdc++.
+
+LIBS    = $(ARLIB) $(ARLINK) $(SHLIB) $(SHLINK) mshlink
+SHFLAGS = -Wl,-soname,$(MSHLINK)
+SHDEPS  = -lm
+DEPLIBS = ../$(SHLIB)
diff --git a/gnu/egcs/libstdc++/config/gnu.ml b/gnu/egcs/libstdc++/config/gnu.ml
new file mode 100644
index 00000000000..2a0380327f7
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/gnu.ml
@@ -0,0 +1,6 @@
+# Elf with shared libm, so we can link it into the shared libstdc++.
+
+LIBS    = $(ARLIB) $(ARLINK) $(SHLIB) $(SHLINK)
+SHFLAGS = -Wl,-soname,$(SHLIB)
+SHDEPS  = -lm
+DEPLIBS = ../$(SHLIB)
diff --git a/gnu/egcs/libstdc++/config/hpux.ml b/gnu/egcs/libstdc++/config/hpux.ml
new file mode 100644
index 00000000000..a39602a6403
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/hpux.ml
@@ -0,0 +1,6 @@
+# HPUX uses the .sl suffix for shared libraries.
+
+SHLIB   = libstdc++.sl
+LIBS    = $(ARLIB) $(ARLINK) $(SHLIB)
+DEPLIBS = ../$(SHLIB)
+SHFLAGS = $(PICFLAG)
diff --git a/gnu/egcs/libstdc++/config/irix5.ml b/gnu/egcs/libstdc++/config/irix5.ml
new file mode 100644
index 00000000000..055c832c26e
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/irix5.ml
@@ -0,0 +1,6 @@
+# We don't need -fpic on IRIX, so let's install both the shared and
+# non-shared versions.
+
+LIBS     = $(ARLIB) $(ARLINK) $(SHLIB) $(SHLINK)
+DEPLIBS  = ../$(SHLIB)
+SHDEPS   = -lm
diff --git a/gnu/egcs/libstdc++/config/linux.ml b/gnu/egcs/libstdc++/config/linux.ml
new file mode 100644
index 00000000000..14dcb45b79d
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/linux.ml
@@ -0,0 +1,11 @@
+# Elf with shared libm, so we can link it into the shared libstdc++.
+
+ARLIB   = libstdc++-$(LIBSTDCXX_INTERFACE)$(LIBC_INTERFACE)$(CXX_INTERFACE)-$(VERSION).a
+MARLINK = libstdc++$(LIBC_INTERFACE)$(CXX_INTERFACE).a.$(LIBSTDCXX_INTERFACE)
+SHLIB   = libstdc++-$(LIBSTDCXX_INTERFACE)$(LIBC_INTERFACE)$(CXX_INTERFACE)-$(VERSION).so
+MSHLINK = libstdc++$(LIBC_INTERFACE)$(CXX_INTERFACE).so.$(LIBSTDCXX_INTERFACE)
+
+LIBS    = $(ARLIB) marlink $(ARLINK) $(SHLIB) mshlink $(SHLINK)
+SHFLAGS = -Wl,-soname,$(MSHLINK)
+SHDEPS  = -lm
+DEPLIBS = ../$(SHLIB)
diff --git a/gnu/egcs/libstdc++/config/linux.mt b/gnu/egcs/libstdc++/config/linux.mt
new file mode 100644
index 00000000000..5848851be8a
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/linux.mt
@@ -0,0 +1,2 @@
+# tell we want the mt-safe version
+MT_CFLAGS = -D_IO_MTSAFE_IO
diff --git a/gnu/egcs/libstdc++/config/openbsd.ml b/gnu/egcs/libstdc++/config/openbsd.ml
new file mode 100644
index 00000000000..09c40235adf
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/openbsd.ml
@@ -0,0 +1,7 @@
+# Base shared lib for OpenBSD i386
+
+LIBS    = $(ARLIB) $(ARLINK) $(SHLIB) $(SHLINK) mshlink
+SHFLAGS = -nostdlib -Wl,-Bshareable,-Bforcearchive
+SHDEPS  = -lm
+DEPLIBS = ../$(SHLIB)
+
diff --git a/gnu/egcs/libstdc++/config/openbsd.mt b/gnu/egcs/libstdc++/config/openbsd.mt
new file mode 100644
index 00000000000..29da11cf454
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/openbsd.mt
@@ -0,0 +1,3 @@
+# tell we want the mt-safe version
+MT_CFLAGS = -D_IO_MTSAFE_IO -D_PTHREADS
+
diff --git a/gnu/egcs/libstdc++/config/posix.mt b/gnu/egcs/libstdc++/config/posix.mt
new file mode 100644
index 00000000000..6afe1e514d9
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/posix.mt
@@ -0,0 +1 @@
+MT_CFLAGS = -D_PTHREADS
diff --git a/gnu/egcs/libstdc++/config/sol2pth.mt b/gnu/egcs/libstdc++/config/sol2pth.mt
new file mode 100644
index 00000000000..6afe1e514d9
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/sol2pth.mt
@@ -0,0 +1 @@
+MT_CFLAGS = -D_PTHREADS
diff --git a/gnu/egcs/libstdc++/config/sol2shm.ml b/gnu/egcs/libstdc++/config/sol2shm.ml
new file mode 100644
index 00000000000..e87f079e46c
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/sol2shm.ml
@@ -0,0 +1,6 @@
+# Solaris2 with shared libm, so we can link it into the shared libstdc++.
+
+LIBS    = $(ARLIB) $(ARLINK) $(SHLIB) $(SHLINK)
+SHFLAGS = -h $(SHLIB)
+SHDEPS  = -lm
+DEPLIBS = ../$(SHLIB)
diff --git a/gnu/egcs/libstdc++/config/sol2solth.mt b/gnu/egcs/libstdc++/config/sol2solth.mt
new file mode 100644
index 00000000000..f809d0ace86
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/sol2solth.mt
@@ -0,0 +1 @@
+MT_CFLAGS = -D_SOLTHREADS
diff --git a/gnu/egcs/libstdc++/config/sunos4.ml b/gnu/egcs/libstdc++/config/sunos4.ml
new file mode 100644
index 00000000000..3c5de27ab50
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/sunos4.ml
@@ -0,0 +1,9 @@
+# SunOS doesn't provide a shared libm, so we have to link with the archive
+# library, even for programs that don't use complex.
+# SunOS requires a version number in shared library filenames.
+
+LIBS    = $(ARLIB) $(ARLINK) $(SHLIB)
+SHFLAGS = $(PICFLAG)
+DEPLIBS = ../$(SHLIB)
+LDLIBS	= -L.. -lstdc++ -lm
+MLDLIBS = -L.. -lstdc++ -lm
diff --git a/gnu/egcs/libstdc++/config/x86-interix.ml b/gnu/egcs/libstdc++/config/x86-interix.ml
new file mode 100644
index 00000000000..8b8774e3a7a
--- /dev/null
+++ b/gnu/egcs/libstdc++/config/x86-interix.ml
@@ -0,0 +1,9 @@
+# x86 Interix. SHLINK is defined to be .dummy to avoid running into 
+# the lack of symbolic links.
+
+SHLINK  = .dummy
+SHLIB   = libstdc++.so
+LIBS    = $(ARLIB) $(SHLIB)
+DEPLIBS = ../$(SHLIB)
+SHFLAGS = $(PICFLAG)
+
diff --git a/gnu/egcs/libstdc++/configure.in b/gnu/egcs/libstdc++/configure.in
new file mode 100644
index 00000000000..8262565bd88
--- /dev/null
+++ b/gnu/egcs/libstdc++/configure.in
@@ -0,0 +1,215 @@
+# This file is a shell script fragment that supplies the information
+# necessary for a configure script to process the program in
+# this directory.  For more information, look at ../configure.
+
+# find a possible extension of the just-built C++ compiler. Note that this
+# is not the only choice, taking into cross and canadian cross into
+# account, and we need to search for with and without the extension.
+case "${host_alias}" in
+*cygwin* | *mingw32*)
+  EXEEXT=.exe
+  ;;
+*)
+  EXEEXT=
+  ;;
+esac
+
+# If the language specific compiler does not exist, but the "gcc" directory 
+# does, we do not build anything. Note, $r is set by the top-level Makefile.
+# Note that when we look for the compiler, we search both with and without
+# extension to handle cross and canadian cross builds. 
+# Note that if $norecursion is set we're being called from config.status,
+# so don't check for the compiler; we might be doing a make clean.
+compiler_name=cc1plus
+rm -f skip-this-dir
+if test -n "$r" && [ -z "$norecursion" ] ; then
+  if test -d "$r"/gcc; then
+    if test -f "$r"/gcc/$compiler_name \
+       || test -f "$r"/gcc/$compiler_name$EXEEXT; then
+      true
+    else
+      echo "rm -f multilib.out" > skip-this-dir
+    fi
+  fi
+fi
+
+if [ "${srcdir}" = "." ] ; then
+  if [ "${with_target_subdir}" != "." ] ; then
+    topsrcdir=${with_multisrctop}../..
+  else
+    topsrcdir=${with_multisrctop}..
+  fi
+else
+  topsrcdir=${srcdir}/..
+fi
+
+if [ -d ${topsrcdir}/gcc ] ; then
+  configdirs="tests testsuite"
+else
+  configdirs="tests"
+fi
+srctrigger=sinst.cc
+srcname="ANSI C++ library"
+package_makefile_frag=Make.pack
+package_makefile_rules_frag=Make.pack.r
+
+# per-host:
+
+# per-target:
+
+echo "# Warning: this fragment is automatically generated" > temp.mt
+frags=
+
+# If they didn't specify --enable-shared, don't generate shared libs.
+case "${enable_shared}" in
+  yes) shared=yes ;;
+  no) shared=no ;;
+  *libstdc++*) shared=yes ;;
+  *) shared=no ;;
+esac
+
+if [ "${shared}" = "yes" ]; then
+  case "${target}" in
+    alpha*-*-linux*)	frags=../../config/mh-elfalphapic ;;
+    arm*-*-*)		frags=../../config/mh-armpic ;;
+    hppa*-*-*)		frags=../../config/mh-papic ;;
+    i[3456]86-*-*)	frags=../../config/mh-x86pic ;;
+    powerpc*-*-aix*)	;;
+    powerpc*-*-*)	frags=../../config/mh-ppcpic ;;
+    *-*-*) 		frags=../../config/mh-${target_cpu}pic ;;
+  esac
+  case "${target}" in
+    *-dec-osf*)		frags="${frags} dec-osf.ml";;
+    *-*-hpux*)		frags="${frags} hpux.ml" ;;
+    *-*-irix[56]*)	frags="${frags} irix5.ml" ;;
+    *-*-linux*aout*)	;;
+    *-*-freebsd2)	;;
+    *-*-freebsd*)	frags="${frags} freebsd.ml" ;;
+    *-*-linux*)		frags="${frags} linux.ml" ;;
+    *-*-openbsd*)		frags="${frags} openbsd.ml" ;;
+    *-*-sysv[45]*|*-*-udk*)	frags="${frags} elf.ml" ;;
+    *-*-solaris*)	frags="${frags} sol2shm.ml" ;;
+    *-*-sunos4*)	frags="${frags} sunos4.ml" ;;
+    *-*-aix*)		frags="${frags} aix.ml" ;;
+    i[3456]86-*-interix*)	frags="${frags} x86-interix.ml" ;;
+    *-*-gnu*)		frags="${frags} gnu.ml" ;;
+  esac
+fi
+
+# Make sure the right flags are defined for multi-threading.
+case "${target}" in
+  alpha*-*-linux-gnulibc1)	frags="${frags} linux.mt" ;;
+  powerpc*-*-linux-gnulibc1)	frags="${frags} linux.mt" ;;
+  *-*-linux-gnu)		frags="${frags} linux.mt" ;;
+  *-*-openbsd*)		
+  	case "x${enable_threads}" in
+		xyes|xposix)	frags="${frags} openbsd.mt" ;;
+	esac;;
+  m68k-motorola-sysv)		frags="${frags} delta.mt" ;;
+  *-*-solaris*)
+    case "x${enable_threads}" in
+      xposix)			frags="${frags} sol2pth.mt" ;;
+      xsolaris)			frags="${frags} sol2solth.mt" ;;
+    esac ;;
+  *)
+    case "x${enable_threads}" in
+      xposix)			frags="${frags} posix.mt" ;;
+    esac ;;
+esac
+
+for frag in ${frags}; do
+  case ${frag} in
+    ../* )
+      if [ ${srcdir} = . ]; then
+	[ -n "${with_target_subdir}" ] && frag=../${frag}
+	[ -n "${with_multisrctop}" ] && frag=${with_multisrctop}${frag}
+      fi
+      ;;
+  esac
+  frag=${srcdir}/config/$frag
+  if [ -f ${frag} ]; then
+    echo "Appending ${frag} to target-mkfrag"
+    echo "# Following fragment copied from ${frag}" >> temp.mt
+    cat ${frag} >> temp.mt
+  fi
+done
+
+target_makefile_frag=target-mkfrag
+${moveifchange} temp.mt target-mkfrag
+
+LIBDIR=yes
+TO_TOPDIR=../
+ALL='libs'
+XCXXINCLUDES="-I${srcdir} -I${srcdir}/stl -I${TO_TOPDIR}libio -I${srcdir}/${TO_TOPDIR}libio"
+MOSTLYCLEAN='*.o pic stamp-picdir core so_locations $(MOSTLYCLEAN_JUNK)'
+CLEAN='$(CLEAN_JUNK)'
+EXTRA_DISTCLEAN='target-mkfrag'
+
+(. ${srcdir}/${TO_TOPDIR}libio/config.shared) >${package_makefile_frag} 2>${package_makefile_rules_frag}
+
+. ${topsrcdir}/config.if
+echo "
+LIBSTDCXX_INTERFACE=${libstdcxx_interface}
+CXX_INTERFACE=${cxx_interface}
+LIBC_INTERFACE=${libc_interface}
+" >> ${package_makefile_frag}
+
+# This duplicated the AC_PROG_LN_S macro in GNU autoconf.
+rm -f conttestdata
+if ln -s X conftestdata 2>/dev/null
+then
+  rm -f conftestdata
+  LN_S="ln -s"
+else
+  LN_S=ln
+fi
+echo "
+LN_S=$LN_S
+" >> ${package_makefile_frag}
+
+# post-target:
+
+# If cross-compiling, we install in $(tooldir)/lib or in $(libsubdir)
+# depending on --enable-version-specific-runtime-libs.
+if [ -n "${with_cross_host}" ] ; then
+    rm -f Makefile.tem
+    sed \
+        -e 's|^\([ 	]*INSTALLDIR[ 	]*=[ 	]*\)\$(libdir)|\1$(tooldir)/lib|' \
+        Makefile >Makefile.tem
+    mv -f Makefile.tem Makefile
+fi
+
+# enable multilib-ing by default.
+if [ -z "${enable_multilib}" ]; then
+    enable_multilib=yes
+fi
+
+. ${topsrcdir}/config-ml.in
+
+gxx_include_dir=
+# Specify the g++ header file directory
+# Check whether --with-gxx-include-dir or --without-gxx-include-dir was given.
+if test "${with_gxx_include_dir+set}" = set; then
+  withval="$with_gxx_include_dir"
+  case "${withval}" in
+    yes)
+      echo "configure.in: error: bad value ${withval} given for g++ include directory" 1>&2
+      exit 1
+      ;;
+    no)	;;
+    *)	gxx_include_dir=$with_gxx_include_dir ;;
+  esac
+fi
+
+if test x${gxx_include_dir} = x; then
+  if test x${enable_version_specific_runtime_libs} = xyes; then
+    gxx_include_dir='${libsubdir}/include/g++'
+  else
+    gxx_include_dir='${prefix}/include/g++'-${libstdcxx_interface}
+  fi
+fi
+
+rm -f Makefile.tem
+sed -e "s%^gxx_include_dir[ 	]*=.*$%gxx_include_dir=${gxx_include_dir}%" \
+       Makefile >Makefile.tem
+mv -f Makefile.tem Makefile
diff --git a/gnu/egcs/libstdc++/csetjmp b/gnu/egcs/libstdc++/csetjmp
new file mode 100644
index 00000000000..4bba048dcb5
--- /dev/null
+++ b/gnu/egcs/libstdc++/csetjmp
@@ -0,0 +1,8 @@
+// The -*- C++ -*- setjmp/longjmp header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __CSETJMP__
+#define __CSETJMP__
+#include <setjmp.h>
+#endif
+
diff --git a/gnu/egcs/libstdc++/csignal b/gnu/egcs/libstdc++/csignal
new file mode 100644
index 00000000000..6febfb7b2ed
--- /dev/null
+++ b/gnu/egcs/libstdc++/csignal
@@ -0,0 +1,7 @@
+// The -*- C++ -*- signal handling header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __CSIGNAL__
+#define __CSIGNAL__
+#include <signal.h>
+#endif
diff --git a/gnu/egcs/libstdc++/cstdarg b/gnu/egcs/libstdc++/cstdarg
new file mode 100644
index 00000000000..324f5a1c19b
--- /dev/null
+++ b/gnu/egcs/libstdc++/cstdarg
@@ -0,0 +1,7 @@
+// -*- C++ -*- forwarding header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __CSTDARG__
+#define __CSTDARG__
+#include <stdarg.h>
+#endif
diff --git a/gnu/egcs/libstdc++/cstddef b/gnu/egcs/libstdc++/cstddef
new file mode 100644
index 00000000000..db5cbe40037
--- /dev/null
+++ b/gnu/egcs/libstdc++/cstddef
@@ -0,0 +1,7 @@
+// -*- C++ -*- forwarding header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __CSTDDEF__
+#define __CSTDDEF__
+#include <stddef.h>
+#endif
diff --git a/gnu/egcs/libstdc++/cstdio b/gnu/egcs/libstdc++/cstdio
new file mode 100644
index 00000000000..1fe1456b5bd
--- /dev/null
+++ b/gnu/egcs/libstdc++/cstdio
@@ -0,0 +1,7 @@
+// The -*- C++ -*- standard I/O header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __CSTDIO__
+#define __CSTDIO__
+#include <stdio.h>
+#endif
diff --git a/gnu/egcs/libstdc++/cstdlib b/gnu/egcs/libstdc++/cstdlib
new file mode 100644
index 00000000000..e7c1a5160a5
--- /dev/null
+++ b/gnu/egcs/libstdc++/cstdlib
@@ -0,0 +1,23 @@
+// The -*- C++ -*- standard library header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __CSTDLIB__
+#define __CSTDLIB__
+#include <stdlib.h>
+
+#ifdef __GNUG__
+#pragma interface "cstdlib"
+#endif
+
+extern "C++" {
+
+#if _G_HAS_LABS
+inline long   abs(long x)		{ return labs (x); }
+#else
+inline long   abs(long x)		{ return x >= 0 ? x : -x; }
+#endif
+//inline ldiv_t div(long x, long y)	{ return ldiv (x, y); }
+
+} // extern "C++"
+
+#endif
diff --git a/gnu/egcs/libstdc++/cstdlibi.cc b/gnu/egcs/libstdc++/cstdlibi.cc
new file mode 100644
index 00000000000..abbfa03464a
--- /dev/null
+++ b/gnu/egcs/libstdc++/cstdlibi.cc
@@ -0,0 +1,7 @@
+// Implementation file for the -*- C++ -*- standard library header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifdef __GNUG__
+#pragma implementation "cstdlib"
+#endif
+#include <cstdlib>
diff --git a/gnu/egcs/libstdc++/cstring b/gnu/egcs/libstdc++/cstring
new file mode 100644
index 00000000000..d8d03a765b6
--- /dev/null
+++ b/gnu/egcs/libstdc++/cstring
@@ -0,0 +1,96 @@
+// The -*- C++ -*- null-terminated string header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __CSTRING__
+#define __CSTRING__
+
+#include <string.h>
+
+#if 0 // Let's not bother with this just yet.
+#include <cstddef>
+
+#ifdef __GNUG__
+#pragma interface "cstring"
+#endif
+
+// The ANSI C prototypes for these functions have a const argument type and
+// non-const return type, so we can't use them.
+
+extern "C++" {
+extern inline const char *
+_G_strchr (const char *s, int c)
+{
+  return strchr (s, c);
+}
+
+extern inline char *
+_G_strchr (char *s, int c)
+{
+  return const_cast<char *> (strchr (s, c));
+}
+
+extern inline const char *
+_G_strpbrk (const char *s1, const char *s2)
+{
+  return strpbrk (s1, s2);
+}
+
+extern inline char *
+_G_strpbrk (char *s1, const char *s2)
+{
+  return const_cast<char *> (strpbrk (s1, s2));
+}
+
+extern inline const char *
+_G_strrchr (const char *s, int c)
+{
+  return strrchr (s, c);
+}
+
+extern inline char *
+_G_strrchr (char *s, int c)
+{
+  return const_cast<char *> (strrchr (s, c));
+}
+
+extern inline const char *
+_G_strstr (const char *s1, const char *s2)
+{
+  return strstr (s1, s2);
+}
+
+extern inline char *
+_G_strstr (char *s1, const char *s2)
+{
+  return const_cast<char *> (strstr (s1, s2));
+}
+
+extern inline const void *
+_G_memchr (const void *s, int c, size_t n)
+{
+  return memchr (s, c, n);
+}
+
+extern inline void *
+_G_memchr (void *s, int c, size_t n)
+{
+  return const_cast<void *> (memchr (s, c, n));
+}
+} // extern "C++"
+
+// Lose any vendor macros for these functions.
+#undef strchr
+#undef strpbrk
+#undef strrchr
+#undef strstr
+#undef memchr
+
+// Ewww, namespace pollution.  Anyone have a better idea?
+#define strchr  _G_strchr
+#define strpbrk _G_strpbrk
+#define strrchr _G_strrchr
+#define strstr  _G_strstr
+#define memchr  _G_memchr
+#endif // 0
+
+#endif // !defined (__CSTRING__)
diff --git a/gnu/egcs/libstdc++/cstringi.cc b/gnu/egcs/libstdc++/cstringi.cc
new file mode 100644
index 00000000000..2676febc9b0
--- /dev/null
+++ b/gnu/egcs/libstdc++/cstringi.cc
@@ -0,0 +1,7 @@
+// Implementation file for the -*- C++ -*- null-terminated string header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifdef __GNUG__
+#pragma implementation "cstring"
+#endif
+#include <cstring>
diff --git a/gnu/egcs/libstdc++/ctime b/gnu/egcs/libstdc++/ctime
new file mode 100644
index 00000000000..0184da5929f
--- /dev/null
+++ b/gnu/egcs/libstdc++/ctime
@@ -0,0 +1,7 @@
+// The -*- C++ -*- time header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __CTIME__
+#define __CTIME__
+#include <time.h>
+#endif
diff --git a/gnu/egcs/libstdc++/cwchar b/gnu/egcs/libstdc++/cwchar
new file mode 100644
index 00000000000..1674c12b61f
--- /dev/null
+++ b/gnu/egcs/libstdc++/cwchar
@@ -0,0 +1,7 @@
+// The -*- C++ -*- wide character header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __CWCHAR__
+#define __CWCHAR__
+#include <wchar.h>
+#endif
diff --git a/gnu/egcs/libstdc++/cwctype b/gnu/egcs/libstdc++/cwctype
new file mode 100644
index 00000000000..81122012bd0
--- /dev/null
+++ b/gnu/egcs/libstdc++/cwctype
@@ -0,0 +1,7 @@
+// The -*- C++ -*- wide character type header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __CWCTYPE__
+#define __CWCTYPE__
+#include <wctype.h>
+#endif
diff --git a/gnu/egcs/libstdc++/fstream b/gnu/egcs/libstdc++/fstream
new file mode 100644
index 00000000000..2c35ca92b03
--- /dev/null
+++ b/gnu/egcs/libstdc++/fstream
@@ -0,0 +1,7 @@
+// -*- C++ -*- forwarding header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __FSTREAM__
+#define __FSTREAM__
+#include <fstream.h>
+#endif
diff --git a/gnu/egcs/libstdc++/iomanip b/gnu/egcs/libstdc++/iomanip
new file mode 100644
index 00000000000..817948579ce
--- /dev/null
+++ b/gnu/egcs/libstdc++/iomanip
@@ -0,0 +1,7 @@
+// -*- C++ -*- forwarding header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __IOMANIP__
+#define __IOMANIP__
+#include <iomanip.h>
+#endif
diff --git a/gnu/egcs/libstdc++/iosfwd b/gnu/egcs/libstdc++/iosfwd
new file mode 100644
index 00000000000..8314cf7b73f
--- /dev/null
+++ b/gnu/egcs/libstdc++/iosfwd
@@ -0,0 +1,15 @@
+// -*- C++ -*- I/O forward declaration header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __IOSFWD__
+#define __IOSFWD__
+class ios;
+class streambuf;
+class istream;
+class ostream;
+class iostream;
+class filebuf;
+class ifstream;
+class ofstream;
+class fstream;
+#endif
diff --git a/gnu/egcs/libstdc++/iostream b/gnu/egcs/libstdc++/iostream
new file mode 100644
index 00000000000..7ecba6e8daf
--- /dev/null
+++ b/gnu/egcs/libstdc++/iostream
@@ -0,0 +1,7 @@
+// -*- C++ -*- forwarding header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __IOSTREAM__
+#define __IOSTREAM__
+#include <iostream.h>
+#endif
diff --git a/gnu/egcs/libstdc++/sinst.cc b/gnu/egcs/libstdc++/sinst.cc
new file mode 100644
index 00000000000..0b3617ece62
--- /dev/null
+++ b/gnu/egcs/libstdc++/sinst.cc
@@ -0,0 +1,135 @@
+// Instantiation file for the -*- C++ -*- string classes.
+// Copyright (C) 1994 Free Software Foundation
+
+// This file is part of the GNU ANSI 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, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+// As a special exception, if you link this library with files
+// compiled with a GNU compiler to produce an executable, this does not 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.
+
+// Written by Jason Merrill based upon the specification by Takanori Adachi
+// in ANSI X3J16/94-0013R2.
+
+#ifdef __GNUG__
+#ifdef TRAITS
+#ifdef C
+#pragma implementation "std/straits.h"
+#endif
+#endif
+#endif
+
+#include <string>
+
+#ifdef C
+typedef char c;
+#endif
+#ifdef W
+typedef wchar_t c;
+#endif
+
+#if defined(TRAITS) && !defined(C)
+template class string_char_traits <c>;
+#else
+/* string_char_traits<char> is already explicitly specialized in
+   std/straits.h.  */
+#endif
+
+typedef basic_string <c> s;
+
+#ifdef MAIN
+template class basic_string <c>;
+#endif
+
+#ifdef ADDSS
+template s operator+ (const s&, const s&);
+#endif
+#ifdef ADDPS
+template s operator+ (const c*, const s&);
+#endif
+#ifdef ADDCS
+template s operator+ (c, const s&);
+#endif
+#ifdef ADDSP
+template s operator+ (const s&, const c*);
+#endif
+#ifdef ADDSC
+template s operator+ (const s&, c);
+#endif
+#ifdef EQSS
+template bool operator== (const s&, const s&);
+#endif
+#ifdef EQPS
+template bool operator== (const c*, const s&);
+#endif
+#ifdef EQSP
+template bool operator== (const s&, const c*);
+#endif
+#ifdef NESS
+template bool operator!= (const s&, const s&);
+#endif
+#ifdef NEPS
+template bool operator!= (const c*, const s&);
+#endif
+#ifdef NESP
+template bool operator!= (const s&, const c*);
+#endif
+#ifdef LTSS
+template bool operator< (const s&, const s&);
+#endif
+#ifdef LTPS
+template bool operator< (const c*, const s&);
+#endif
+#ifdef LTSP
+template bool operator< (const s&, const c*);
+#endif
+#ifdef GTSS
+template bool operator> (const s&, const s&);
+#endif
+#ifdef GTPS
+template bool operator> (const c*, const s&);
+#endif
+#ifdef GTSP
+template bool operator> (const s&, const c*);
+#endif
+#ifdef LESS
+template bool operator<= (const s&, const s&);
+#endif
+#ifdef LEPS
+template bool operator<= (const c*, const s&);
+#endif
+#ifdef LESP
+template bool operator<= (const s&, const c*);
+#endif
+#ifdef GESS
+template bool operator>= (const s&, const s&);
+#endif
+#ifdef GEPS
+template bool operator>= (const c*, const s&);
+#endif
+#ifdef GESP
+template bool operator>= (const s&, const c*);
+#endif
+#ifdef EXTRACT
+template istream& operator>> (istream&, s&);
+#endif // EXTRACT
+#ifdef INSERT
+template ostream& operator<< (ostream&, const s&);
+#endif // INSERT
+#ifdef GETLINE
+template istream& getline (istream&, s&, c);
+#endif
diff --git a/gnu/egcs/libstdc++/std/bastring.cc b/gnu/egcs/libstdc++/std/bastring.cc
new file mode 100644
index 00000000000..3093b9e129d
--- /dev/null
+++ b/gnu/egcs/libstdc++/std/bastring.cc
@@ -0,0 +1,524 @@
+// Member templates for the -*- C++ -*- string classes.
+// Copyright (C) 1994 Free Software Foundation
+
+// This file is part of the GNU ANSI 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, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+// As a special exception, if you link this library with files
+// compiled with a GNU compiler to produce an executable, this does not 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.
+
+// Written by Jason Merrill based upon the specification by Takanori Adachi
+// in ANSI X3J16/94-0013R2.
+
+extern "C++" {
+template <class charT, class traits, class Allocator>
+inline void * basic_string <charT, traits, Allocator>::Rep::
+operator new (size_t s, size_t extra)
+{
+  return Allocator::allocate(s + extra * sizeof (charT));
+}
+
+template <class charT, class traits, class Allocator>
+inline void basic_string <charT, traits, Allocator>::Rep::
+operator delete (void * ptr)
+{
+  Allocator::deallocate(ptr, sizeof(Rep) +
+			reinterpret_cast<Rep *>(ptr)->res *
+			sizeof (charT));
+}
+
+template <class charT, class traits, class Allocator>
+inline size_t basic_string <charT, traits, Allocator>::Rep::
+frob_size (size_t s)
+{
+  size_t i = 16;
+  while (i < s) i *= 2;
+  return i;
+}
+
+template <class charT, class traits, class Allocator>
+inline basic_string <charT, traits, Allocator>::Rep *
+basic_string <charT, traits, Allocator>::Rep::
+create (size_t extra)
+{
+  extra = frob_size (extra + 1);
+  Rep *p = new (extra) Rep;
+  p->res = extra;
+  p->ref = 1;
+  p->selfish = false;
+  return p;
+}
+
+template <class charT, class traits, class Allocator>
+charT * basic_string <charT, traits, Allocator>::Rep::
+clone ()
+{
+  Rep *p = Rep::create (len);
+  p->copy (0, data (), len);
+  p->len = len;
+  return p->data ();
+}
+
+template <class charT, class traits, class Allocator>
+inline bool basic_string <charT, traits, Allocator>::Rep::
+excess_slop (size_t s, size_t r)
+{
+  return 2 * (s <= 16 ? 16 : s) < r;
+}
+
+template <class charT, class traits, class Allocator>
+inline bool basic_string <charT, traits, Allocator>::
+check_realloc (basic_string::size_type s) const
+{
+  s += sizeof (charT);
+  rep ()->selfish = false;
+  return (rep ()->ref > 1
+	  || s > capacity ()
+	  || Rep::excess_slop (s, capacity ()));
+}
+
+template <class charT, class traits, class Allocator>
+void basic_string <charT, traits, Allocator>::
+alloc (basic_string::size_type size, bool save)
+{
+  if (! check_realloc (size))
+    return;
+
+  Rep *p = Rep::create (size);
+
+  if (save)
+    {
+      p->copy (0, data (), length ());
+      p->len = length ();
+    }
+  else
+    p->len = 0;
+
+  repup (p);
+}
+
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>&
+basic_string <charT, traits, Allocator>::
+replace (size_type pos1, size_type n1,
+	 const basic_string& str, size_type pos2, size_type n2)
+{
+  const size_t len2 = str.length ();
+
+  if (pos1 == 0 && n1 >= length () && pos2 == 0 && n2 >= len2)
+    return operator= (str);
+
+  OUTOFRANGE (pos2 > len2);
+
+  if (n2 > len2 - pos2)
+    n2 = len2 - pos2;
+
+  return replace (pos1, n1, str.data () + pos2, n2);
+}
+
+template <class charT, class traits, class Allocator>
+inline void basic_string <charT, traits, Allocator>::Rep::
+copy (size_t pos, const charT *s, size_t n)
+{
+  if (n)
+    traits::copy (data () + pos, s, n);
+}
+
+template <class charT, class traits, class Allocator>
+inline void basic_string <charT, traits, Allocator>::Rep::
+move (size_t pos, const charT *s, size_t n)
+{
+  if (n)
+    traits::move (data () + pos, s, n);
+}
+
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>&
+basic_string <charT, traits, Allocator>::
+replace (size_type pos, size_type n1, const charT* s, size_type n2)
+{
+  const size_type len = length ();
+  OUTOFRANGE (pos > len);
+  if (n1 > len - pos)
+    n1 = len - pos;
+  LENGTHERROR (len - n1 > max_size () - n2);
+  size_t newlen = len - n1 + n2;
+
+  if (check_realloc (newlen))
+    {
+      Rep *p = Rep::create (newlen);
+      p->copy (0, data (), pos);
+      p->copy (pos + n2, data () + pos + n1, len - (pos + n1));
+      p->copy (pos, s, n2);
+      repup (p);
+    }
+  else
+    {
+      rep ()->move (pos + n2, data () + pos + n1, len - (pos + n1));
+      rep ()->copy (pos, s, n2);
+    }
+  rep ()->len = newlen;
+
+  return *this;
+}
+
+template <class charT, class traits, class Allocator>
+inline void basic_string <charT, traits, Allocator>::Rep::
+set (size_t pos, const charT c, size_t n)
+{
+  traits::set  (data () + pos, c, n);
+}
+
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>& basic_string <charT, traits, Allocator>::
+replace (size_type pos, size_type n1, size_type n2, charT c)
+{
+  const size_t len = length ();
+  OUTOFRANGE (pos > len);
+  if (n1 > len - pos)
+    n1 = len - pos;
+  LENGTHERROR (len - n1 > max_size () - n2);
+  size_t newlen = len - n1 + n2;
+
+  if (check_realloc (newlen))
+    {
+      Rep *p = Rep::create (newlen);
+      p->copy (0, data (), pos);
+      p->copy (pos + n2, data () + pos + n1, len - (pos + n1));
+      p->set  (pos, c, n2);
+      repup (p);
+    }
+  else
+    {
+      rep ()->move (pos + n2, data () + pos + n1, len - (pos + n1));
+      rep ()->set  (pos, c, n2);
+    }
+  rep ()->len = newlen;
+
+  return *this;
+}
+
+template <class charT, class traits, class Allocator>
+void basic_string <charT, traits, Allocator>::
+resize (size_type n, charT c)
+{
+  LENGTHERROR (n > max_size ());
+
+  if (n > length ())
+    append (n - length (), c);
+  else
+    erase (n);
+}
+
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+copy (charT* s, size_type n, size_type pos) const
+{
+  OUTOFRANGE (pos > length ());
+
+  if (n > length () - pos)
+    n = length () - pos;
+
+  traits::copy (s, data () + pos, n);
+  return n;
+}
+
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+find (const charT* s, size_type pos, size_type n) const
+{
+  size_t xpos = pos;
+  for (; xpos + n <= length (); ++xpos)
+    if (traits::eq (data () [xpos], *s)
+	&& traits::compare (data () + xpos, s, n) == 0)
+      return xpos;
+  return npos;
+}
+
+template <class charT, class traits, class Allocator>
+inline basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+_find (const charT* ptr, charT c, size_type xpos, size_type len)
+{
+  for (; xpos < len; ++xpos)
+    if (traits::eq (ptr [xpos], c))
+      return xpos;
+  return npos;
+}
+
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+find (charT c, size_type pos) const
+{
+  return _find (data (), c, pos, length ());
+}
+
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+rfind (const charT* s, size_type pos, size_type n) const
+{
+  if (n > length ())
+    return npos;
+
+  size_t xpos = length () - n;
+  if (xpos > pos)
+    xpos = pos;
+
+  for (++xpos; xpos-- > 0; )
+    if (traits::eq (data () [xpos], *s)
+	&& traits::compare (data () + xpos, s, n) == 0)
+      return xpos;
+  return npos;
+}
+
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+rfind (charT c, size_type pos) const
+{
+  if (1 > length ())
+    return npos;
+
+  size_t xpos = length () - 1;
+  if (xpos > pos)
+    xpos = pos;
+
+  for (++xpos; xpos-- > 0; )
+    if (traits::eq (data () [xpos], c))
+      return xpos;
+  return npos;
+}
+
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+find_first_of (const charT* s, size_type pos, size_type n) const
+{
+  size_t xpos = pos;
+  for (; xpos < length (); ++xpos)
+    if (_find (s, data () [xpos], 0, n) != npos)
+      return xpos;
+  return npos;
+}
+
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+find_last_of (const charT* s, size_type pos, size_type n) const
+{
+  if (length() == 0)
+    return npos;
+  size_t xpos = length () - 1;
+  if (xpos > pos)
+    xpos = pos;
+  for (++xpos; xpos-- > 0;)
+    if (_find (s, data () [xpos], 0, n) != npos)
+      return xpos;
+  return npos;
+}
+
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+find_first_not_of (const charT* s, size_type pos, size_type n) const
+{
+  size_t xpos = pos;
+  for (; xpos < length (); ++xpos)
+    if (_find (s, data () [xpos], 0, n) == npos)
+      return xpos;
+  return npos;
+}
+
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+find_first_not_of (charT c, size_type pos) const
+{
+  size_t xpos = pos;
+  for (; xpos < length (); ++xpos)
+    if (traits::ne (data () [xpos], c))
+      return xpos;
+  return npos;
+}
+
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+find_last_not_of (const charT* s, size_type pos, size_type n) const
+{
+  if (length() == 0)
+    return npos;
+  size_t xpos = length () - 1;
+  if (xpos > pos)
+    xpos = pos;
+  for (++xpos; xpos-- > 0;)
+    if (_find (s, data () [xpos], 0, n) == npos)
+      return xpos;
+  return npos;
+}
+
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+find_last_not_of (charT c, size_type pos) const
+{
+  if (length() == 0)
+    return npos;
+  size_t xpos = length () - 1;
+  if (xpos > pos)
+    xpos = pos;
+  for (++xpos; xpos-- > 0;)
+    if (traits::ne (data () [xpos], c))
+      return xpos;
+  return npos;
+}
+
+template <class charT, class traits, class Allocator>
+int basic_string <charT, traits, Allocator>::
+compare (const basic_string& str, size_type pos, size_type n) const
+{
+  OUTOFRANGE (pos > length ());
+
+  size_t rlen = length () - pos;
+  if (rlen > n)
+    rlen = n;
+  if (rlen > str.length ())
+    rlen = str.length ();
+  int r = traits::compare (data () + pos, str.data (), rlen);
+  if (r != 0)
+    return r;
+  if (rlen == n)
+    return 0;
+  return (length () - pos) - str.length ();
+}
+
+template <class charT, class traits, class Allocator>
+int basic_string <charT, traits, Allocator>::
+compare (const charT* s, size_type pos, size_type n) const
+{
+  OUTOFRANGE (pos > length ());
+
+  size_t rlen = length () - pos;
+  if (rlen > n)
+    rlen = n;
+  int r = traits::compare (data () + pos, s, rlen);
+  if (r != 0)
+    return r;
+  return (length () - pos) - n;
+}
+
+#include <iostream.h>
+
+template <class charT, class traits, class Allocator>
+istream &
+operator>> (istream &is, basic_string <charT, traits, Allocator> &s)
+{
+  int w = is.width (0);
+  if (is.ipfx0 ())
+    {
+      register streambuf *sb = is.rdbuf ();
+      s.resize (0);
+      while (1)
+	{
+	  int ch = sb->sbumpc ();
+	  if (ch == EOF)
+	    {
+	      is.setstate (ios::eofbit);
+	      break;
+	    }
+	  else if (traits::is_del (ch))
+	    {
+	      sb->sungetc ();
+	      break;
+	    }
+	  s += static_cast<charT> (ch);
+	  if (--w == 1)
+	    break;
+	}
+    }
+
+  is.isfx ();
+  if (s.length () == 0)
+    is.setstate (ios::failbit);
+
+  return is;
+}
+
+template <class charT, class traits, class Allocator>
+ostream &
+operator<< (ostream &o, const basic_string <charT, traits, Allocator>& s)
+{
+  return o.write (s.data (), s.length ());
+}
+
+template <class charT, class traits, class Allocator>
+istream&
+getline (istream &is, basic_string <charT, traits, Allocator>& s, charT delim)
+{
+  if (is.ipfx1 ())
+    {
+      _IO_size_t count = 0;
+      streambuf *sb = is.rdbuf ();
+      s.resize (0);
+
+      while (1)
+	{
+	  int ch = sb->sbumpc ();
+	  if (ch == EOF)
+	    {
+	      is.setstate (count == 0
+			   ? (ios::failbit|ios::eofbit)
+			   : ios::eofbit);
+	      break;
+	    }
+
+	  ++count;
+
+	  if (ch == delim)
+	    break;
+
+	  s += static_cast<charT> (ch);
+
+	  if (s.length () == s.npos - 1)
+	    {
+	      is.setstate (ios::failbit);
+	      break;
+	    }
+	}
+    }
+
+  // We need to be friends with istream to do this.
+  // is._gcount = count;
+  is.isfx ();
+
+  return is;
+}
+
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>::Rep
+basic_string<charT, traits, Allocator>::nilRep = { 0, 0, 1, false };
+
+template <class charT, class traits, class Allocator>
+const basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::npos;
+
+} // extern "C++"
diff --git a/gnu/egcs/libstdc++/std/bastring.h b/gnu/egcs/libstdc++/std/bastring.h
new file mode 100644
index 00000000000..6206713b6c9
--- /dev/null
+++ b/gnu/egcs/libstdc++/std/bastring.h
@@ -0,0 +1,647 @@
+// Main templates for the -*- C++ -*- string classes.
+// Copyright (C) 1994, 1995 Free Software Foundation
+
+// This file is part of the GNU ANSI 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, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+// As a special exception, if you link this library with files
+// compiled with a GNU compiler to produce an executable, this does not 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.
+
+// Written by Jason Merrill based upon the specification by Takanori Adachi
+// in ANSI X3J16/94-0013R2.
+
+#ifndef __BASTRING__
+#define __BASTRING__
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include <cstddef>
+#include <std/straits.h>
+
+// NOTE : This does NOT conform to the draft standard and is likely to change
+#include <alloc.h>
+
+extern "C++" {
+class istream; class ostream;
+
+#include <iterator>
+
+#ifdef __STL_USE_EXCEPTIONS
+
+extern void __out_of_range (const char *);
+extern void __length_error (const char *);
+
+#define OUTOFRANGE(cond) \
+  do { if (cond) __out_of_range (#cond); } while (0)
+#define LENGTHERROR(cond) \
+  do { if (cond) __length_error (#cond); } while (0)
+
+#else
+
+#include <cassert>
+#define OUTOFRANGE(cond) assert (!(cond))
+#define LENGTHERROR(cond) assert (!(cond))
+
+#endif
+
+template <class charT, class traits = string_char_traits<charT>,
+	  class Allocator = alloc >
+class basic_string
+{
+private:
+  struct Rep {
+    size_t len, res, ref;
+    bool selfish;
+
+    charT* data () { return reinterpret_cast<charT *>(this + 1); }
+    charT& operator[] (size_t s) { return data () [s]; }
+    charT* grab () { if (selfish) return clone (); ++ref; return data (); }
+#if defined __i486__ || defined __i586__ || defined __i686__
+    void release ()
+      {
+	size_t __val;
+	asm ("lock; xaddl %0, %2"
+	     : "=r" (__val) : "0" (-1), "m" (ref) : "memory");
+	if (__val == 1)
+	  delete this;
+      }
+#elif defined __sparcv9__
+    void release ()
+      {
+	size_t __newval, __oldval = ref;
+	do
+	  {
+	    __newval = __oldval - 1;
+	    __asm__ ("cas	[%4], %2, %0"
+		     : "=r" (__oldval), "=m" (ref)
+		     : "r" (__oldval), "m" (ref), "r"(&(ref)), "0" (__newval));
+	  }
+	while (__newval != __oldval);
+
+	if (__oldval == 0)
+	  delete this;
+      }
+#else
+    void release () { if (--ref == 0) delete this; }
+#endif
+
+    inline static void * operator new (size_t, size_t);
+    inline static void operator delete (void *);
+    inline static Rep* create (size_t);
+    charT* clone ();
+
+    inline void copy (size_t, const charT *, size_t);
+    inline void move (size_t, const charT *, size_t);
+    inline void set  (size_t, const charT,   size_t);
+
+    inline static bool excess_slop (size_t, size_t);
+    inline static size_t frob_size (size_t);
+
+  private:
+    Rep &operator= (const Rep &);
+  };
+
+public:
+// types:
+  typedef	   traits		traits_type;
+  typedef typename traits::char_type	value_type;
+  typedef	   Allocator		allocator_type;
+
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef charT& reference;
+  typedef const charT& const_reference;
+  typedef charT* pointer;
+  typedef const charT* const_pointer;
+  typedef pointer iterator;
+  typedef const_pointer const_iterator;
+  typedef ::reverse_iterator<iterator> reverse_iterator;
+  typedef ::reverse_iterator<const_iterator> const_reverse_iterator;
+  static const size_type npos = static_cast<size_type>(-1);
+
+private:
+  Rep *rep () const { return reinterpret_cast<Rep *>(dat) - 1; }
+  void repup (Rep *p) { rep ()->release (); dat = p->data (); }
+
+public:
+  const charT* data () const
+    { return rep ()->data(); }
+  size_type length () const
+    { return rep ()->len; }
+  size_type size () const
+    { return rep ()->len; }
+  size_type capacity () const
+    { return rep ()->res; }
+  size_type max_size () const
+    { return (npos - 1)/sizeof (charT); }		// XXX
+  bool empty () const
+    { return size () == 0; }
+
+// _lib.string.cons_ construct/copy/destroy:
+  basic_string& operator= (const basic_string& str)
+    {
+      if (&str != this) { rep ()->release (); dat = str.rep ()->grab (); }
+      return *this;
+    }
+
+  explicit basic_string (): dat (nilRep.grab ()) { }
+  basic_string (const basic_string& str): dat (str.rep ()->grab ()) { }
+  basic_string (const basic_string& str, size_type pos, size_type n = npos)
+    : dat (nilRep.grab ()) { assign (str, pos, n); }
+  basic_string (const charT* s, size_type n)
+    : dat (nilRep.grab ()) { assign (s, n); }
+  basic_string (const charT* s)
+    : dat (nilRep.grab ()) { assign (s); }
+  basic_string (size_type n, charT c)
+    : dat (nilRep.grab ()) { assign (n, c); }
+#ifdef __STL_MEMBER_TEMPLATES
+  template<class InputIterator>
+    basic_string(InputIterator begin, InputIterator end)
+#else
+  basic_string(const_iterator begin, const_iterator end)
+#endif
+    : dat (nilRep.grab ()) { assign (begin, end); }
+
+  ~basic_string ()
+    { rep ()->release (); }
+
+  void swap (basic_string &s) { charT *d = dat; dat = s.dat; s.dat = d; }
+
+  basic_string& append (const basic_string& str, size_type pos = 0,
+			size_type n = npos)
+    { return replace (length (), 0, str, pos, n); }
+  basic_string& append (const charT* s, size_type n)
+    { return replace (length (), 0, s, n); }
+  basic_string& append (const charT* s)
+    { return append (s, traits::length (s)); }
+  basic_string& append (size_type n, charT c)
+    { return replace (length (), 0, n, c); }
+#ifdef __STL_MEMBER_TEMPLATES
+  template<class InputIterator>
+    basic_string& append(InputIterator first, InputIterator last)
+#else
+  basic_string& append(const_iterator first, const_iterator last)
+#endif
+    { return replace (iend (), iend (), first, last); }
+
+  basic_string& assign (const basic_string& str, size_type pos = 0,
+			size_type n = npos)
+    { return replace (0, npos, str, pos, n); }
+  basic_string& assign (const charT* s, size_type n)
+    { return replace (0, npos, s, n); }
+  basic_string& assign (const charT* s)
+    { return assign (s, traits::length (s)); }
+  basic_string& assign (size_type n, charT c)
+    { return replace (0, npos, n, c); }
+#ifdef __STL_MEMBER_TEMPLATES
+  template<class InputIterator>
+    basic_string& assign(InputIterator first, InputIterator last)
+#else
+  basic_string& assign(const_iterator first, const_iterator last)
+#endif
+    { return replace (ibegin (), iend (), first, last); }
+
+  basic_string& operator= (const charT* s)
+    { return assign (s); }
+  basic_string& operator= (charT c)
+    { return assign (1, c); }
+
+  basic_string& operator+= (const basic_string& rhs)
+    { return append (rhs); }
+  basic_string& operator+= (const charT* s)
+    { return append (s); }
+  basic_string& operator+= (charT c)
+    { return append (1, c); }
+
+  basic_string& insert (size_type pos1, const basic_string& str,
+			size_type pos2 = 0, size_type n = npos)
+    { return replace (pos1, 0, str, pos2, n); }
+  basic_string& insert (size_type pos, const charT* s, size_type n)
+    { return replace (pos, 0, s, n); }
+  basic_string& insert (size_type pos, const charT* s)
+    { return insert (pos, s, traits::length (s)); }
+  basic_string& insert (size_type pos, size_type n, charT c)
+    { return replace (pos, 0, n, c); }
+  iterator insert(iterator p, charT c)
+    { size_type __o = p - ibegin ();
+      insert (p - ibegin (), 1, c); selfish ();
+      return ibegin () + __o; }
+  iterator insert(iterator p, size_type n, charT c)
+    { size_type __o = p - ibegin ();
+      insert (p - ibegin (), n, c); selfish ();
+      return ibegin () + __o; }
+#ifdef __STL_MEMBER_TEMPLATES
+  template<class InputIterator>
+    void insert(iterator p, InputIterator first, InputIterator last)
+#else
+  void insert(iterator p, const_iterator first, const_iterator last)
+#endif
+    { replace (p, p, first, last); }
+
+  basic_string& erase (size_type pos = 0, size_type n = npos)
+    { return replace (pos, n, (size_type)0, (charT)0); }
+  iterator erase(iterator p)
+    { size_type __o = p - begin();
+      replace (__o, 1, (size_type)0, (charT)0); selfish ();
+      return ibegin() + __o; }
+  iterator erase(iterator f, iterator l)
+    { size_type __o = f - ibegin();
+      replace (__o, l-f, (size_type)0, (charT)0);selfish ();
+      return ibegin() + __o; }
+
+  basic_string& replace (size_type pos1, size_type n1, const basic_string& str,
+			 size_type pos2 = 0, size_type n2 = npos);
+  basic_string& replace (size_type pos, size_type n1, const charT* s,
+			 size_type n2);
+  basic_string& replace (size_type pos, size_type n1, const charT* s)
+    { return replace (pos, n1, s, traits::length (s)); }
+  basic_string& replace (size_type pos, size_type n1, size_type n2, charT c);
+  basic_string& replace (size_type pos, size_type n, charT c)
+    { return replace (pos, n, 1, c); }
+  basic_string& replace (iterator i1, iterator i2, const basic_string& str)
+    { return replace (i1 - ibegin (), i2 - i1, str); }
+  basic_string& replace (iterator i1, iterator i2, const charT* s, size_type n)
+    { return replace (i1 - ibegin (), i2 - i1, s, n); }
+  basic_string& replace (iterator i1, iterator i2, const charT* s)
+    { return replace (i1 - ibegin (), i2 - i1, s); }
+  basic_string& replace (iterator i1, iterator i2, size_type n, charT c)
+    { return replace (i1 - ibegin (), i2 - i1, n, c); }
+#ifdef __STL_MEMBER_TEMPLATES
+  template<class InputIterator>
+    basic_string& replace(iterator i1, iterator i2,
+			  InputIterator j1, InputIterator j2);
+#else
+  basic_string& replace(iterator i1, iterator i2,
+			const_iterator j1, const_iterator j2);
+#endif
+
+private:
+  static charT eos () { return traits::eos (); }
+  void unique () { if (rep ()->ref > 1) alloc (length (), true); }
+  void selfish () { unique (); rep ()->selfish = true; }
+
+public:
+  charT operator[] (size_type pos) const
+    {
+      if (pos == length ())
+	return eos ();
+      return data ()[pos];
+    }
+
+  reference operator[] (size_type pos)
+    { selfish (); return (*rep ())[pos]; }
+
+  reference at (size_type pos)
+    {
+      OUTOFRANGE (pos >= length ());
+      return (*this)[pos];
+    }
+  const_reference at (size_type pos) const
+    {
+      OUTOFRANGE (pos >= length ());
+      return data ()[pos];
+    }
+
+private:
+  void terminate () const
+    { traits::assign ((*rep ())[length ()], eos ()); }
+
+public:
+  const charT* c_str () const
+    { if (length () == 0) return ""; terminate (); return data (); }
+  void resize (size_type n, charT c);
+  void resize (size_type n)
+    { resize (n, eos ()); }
+  void reserve (size_type) { }
+
+  size_type copy (charT* s, size_type n, size_type pos = 0) const;
+
+  size_type find (const basic_string& str, size_type pos = 0) const
+    { return find (str.data(), pos, str.length()); }
+  size_type find (const charT* s, size_type pos, size_type n) const;
+  size_type find (const charT* s, size_type pos = 0) const
+    { return find (s, pos, traits::length (s)); }
+  size_type find (charT c, size_type pos = 0) const;
+
+  size_type rfind (const basic_string& str, size_type pos = npos) const
+    { return rfind (str.data(), pos, str.length()); }
+  size_type rfind (const charT* s, size_type pos, size_type n) const;
+  size_type rfind (const charT* s, size_type pos = npos) const
+    { return rfind (s, pos, traits::length (s)); }
+  size_type rfind (charT c, size_type pos = npos) const;
+
+  size_type find_first_of (const basic_string& str, size_type pos = 0) const
+    { return find_first_of (str.data(), pos, str.length()); }
+  size_type find_first_of (const charT* s, size_type pos, size_type n) const;
+  size_type find_first_of (const charT* s, size_type pos = 0) const
+    { return find_first_of (s, pos, traits::length (s)); }
+  size_type find_first_of (charT c, size_type pos = 0) const
+    { return find (c, pos); }
+
+  size_type find_last_of (const basic_string& str, size_type pos = npos) const
+    { return find_last_of (str.data(), pos, str.length()); }
+  size_type find_last_of (const charT* s, size_type pos, size_type n) const;
+  size_type find_last_of (const charT* s, size_type pos = npos) const
+    { return find_last_of (s, pos, traits::length (s)); }
+  size_type find_last_of (charT c, size_type pos = npos) const
+    { return rfind (c, pos); }
+
+  size_type find_first_not_of (const basic_string& str, size_type pos = 0) const
+    { return find_first_not_of (str.data(), pos, str.length()); }
+  size_type find_first_not_of (const charT* s, size_type pos, size_type n) const;
+  size_type find_first_not_of (const charT* s, size_type pos = 0) const
+    { return find_first_not_of (s, pos, traits::length (s)); }
+  size_type find_first_not_of (charT c, size_type pos = 0) const;
+
+  size_type find_last_not_of (const basic_string& str, size_type pos = npos) const
+    { return find_last_not_of (str.data(), pos, str.length()); }
+  size_type find_last_not_of (const charT* s, size_type pos, size_type n) const;
+  size_type find_last_not_of (const charT* s, size_type pos = npos) const
+    { return find_last_not_of (s, pos, traits::length (s)); }
+  size_type find_last_not_of (charT c, size_type pos = npos) const;
+
+  basic_string substr (size_type pos = 0, size_type n = npos) const
+    { return basic_string (*this, pos, n); }
+
+  int compare (const basic_string& str, size_type pos = 0, size_type n = npos) const;
+  // There is no 'strncmp' equivalent for charT pointers.
+  int compare (const charT* s, size_type pos, size_type n) const;
+  int compare (const charT* s, size_type pos = 0) const
+    { return compare (s, pos, traits::length (s)); }
+
+  iterator begin () { selfish (); return &(*this)[0]; }
+  iterator end () { selfish (); return &(*this)[length ()]; }
+
+private:
+  iterator ibegin () const { return &(*rep ())[0]; }
+  iterator iend () const { return &(*rep ())[length ()]; }
+
+public:
+  const_iterator begin () const { return ibegin (); }
+  const_iterator end () const { return iend (); }
+
+  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 ()); }
+
+private:
+  void alloc (size_type size, bool save);
+  static size_type _find (const charT* ptr, charT c, size_type xpos, size_type len);
+  inline bool check_realloc (size_type s) const;
+
+  static Rep nilRep;
+  charT *dat;
+};
+
+#ifdef __STL_MEMBER_TEMPLATES
+template <class charT, class traits, class Allocator> template <class InputIterator>
+basic_string <charT, traits, Allocator>& basic_string <charT, traits, Allocator>::
+replace (iterator i1, iterator i2, InputIterator j1, InputIterator j2)
+#else
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>& basic_string <charT, traits, Allocator>::
+replace (iterator i1, iterator i2, const_iterator j1, const_iterator j2)
+#endif
+{
+  const size_type len = length ();
+  size_type pos = i1 - ibegin ();
+  size_type n1 = i2 - i1;
+  size_type n2 = j2 - j1;
+
+  OUTOFRANGE (pos > len);
+  if (n1 > len - pos)
+    n1 = len - pos;
+  LENGTHERROR (len - n1 > max_size () - n2);
+  size_t newlen = len - n1 + n2;
+
+  if (check_realloc (newlen))
+    {
+      Rep *p = Rep::create (newlen);
+      p->copy (0, data (), pos);
+      p->copy (pos + n2, data () + pos + n1, len - (pos + n1));
+      for (; j1 != j2; ++j1, ++pos)
+	traits::assign ((*p)[pos], *j1);
+      repup (p);
+    }
+  else
+    {
+      rep ()->move (pos + n2, data () + pos + n1, len - (pos + n1));
+      for (; j1 != j2; ++j1, ++pos)
+	traits::assign ((*rep ())[pos], *j1);
+    }
+  rep ()->len = newlen;
+
+  return *this;
+}
+
+template <class charT, class traits, class Allocator>
+inline basic_string <charT, traits, Allocator>
+operator+ (const basic_string <charT, traits, Allocator>& lhs,
+	   const basic_string <charT, traits, Allocator>& rhs)
+{
+  basic_string <charT, traits, Allocator> str (lhs);
+  str.append (rhs);
+  return str;
+}
+
+template <class charT, class traits, class Allocator>
+inline basic_string <charT, traits, Allocator>
+operator+ (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
+{
+  basic_string <charT, traits, Allocator> str (lhs);
+  str.append (rhs);
+  return str;
+}
+
+template <class charT, class traits, class Allocator>
+inline basic_string <charT, traits, Allocator>
+operator+ (charT lhs, const basic_string <charT, traits, Allocator>& rhs)
+{
+  basic_string <charT, traits, Allocator> str (1, lhs);
+  str.append (rhs);
+  return str;
+}
+
+template <class charT, class traits, class Allocator>
+inline basic_string <charT, traits, Allocator>
+operator+ (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
+{
+  basic_string <charT, traits, Allocator> str (lhs);
+  str.append (rhs);
+  return str;
+}
+
+template <class charT, class traits, class Allocator>
+inline basic_string <charT, traits, Allocator>
+operator+ (const basic_string <charT, traits, Allocator>& lhs, charT rhs)
+{
+  basic_string <charT, traits, Allocator> str (lhs);
+  str.append (1, rhs);
+  return str;
+}
+
+template <class charT, class traits, class Allocator>
+inline bool
+operator== (const basic_string <charT, traits, Allocator>& lhs,
+	    const basic_string <charT, traits, Allocator>& rhs)
+{
+  return (lhs.compare (rhs) == 0);
+}
+
+template <class charT, class traits, class Allocator>
+inline bool
+operator== (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
+{
+  return (rhs.compare (lhs) == 0);
+}
+
+template <class charT, class traits, class Allocator>
+inline bool
+operator== (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
+{
+  return (lhs.compare (rhs) == 0);
+}
+
+template <class charT, class traits, class Allocator>
+inline bool
+operator!= (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
+{
+  return (rhs.compare (lhs) != 0);
+}
+
+template <class charT, class traits, class Allocator>
+inline bool
+operator!= (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
+{
+  return (lhs.compare (rhs) != 0);
+}
+
+template <class charT, class traits, class Allocator>
+inline bool
+operator< (const basic_string <charT, traits, Allocator>& lhs,
+	    const basic_string <charT, traits, Allocator>& rhs)
+{
+  return (lhs.compare (rhs) < 0);
+}
+
+template <class charT, class traits, class Allocator>
+inline bool
+operator< (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
+{
+  return (rhs.compare (lhs) > 0);
+}
+
+template <class charT, class traits, class Allocator>
+inline bool
+operator< (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
+{
+  return (lhs.compare (rhs) < 0);
+}
+
+template <class charT, class traits, class Allocator>
+inline bool
+operator> (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
+{
+  return (rhs.compare (lhs) < 0);
+}
+
+template <class charT, class traits, class Allocator>
+inline bool
+operator> (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
+{
+  return (lhs.compare (rhs) > 0);
+}
+
+template <class charT, class traits, class Allocator>
+inline bool
+operator<= (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
+{
+  return (rhs.compare (lhs) >= 0);
+}
+
+template <class charT, class traits, class Allocator>
+inline bool
+operator<= (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
+{
+  return (lhs.compare (rhs) <= 0);
+}
+
+template <class charT, class traits, class Allocator>
+inline bool
+operator>= (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
+{
+  return (rhs.compare (lhs) <= 0);
+}
+
+template <class charT, class traits, class Allocator>
+inline bool
+operator>= (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
+{
+  return (lhs.compare (rhs) >= 0);
+}
+
+template <class charT, class traits, class Allocator>
+inline bool
+operator!= (const basic_string <charT, traits, Allocator>& lhs,
+	    const basic_string <charT, traits, Allocator>& rhs)
+{
+  return (lhs.compare (rhs) != 0);
+}
+
+template <class charT, class traits, class Allocator>
+inline bool
+operator> (const basic_string <charT, traits, Allocator>& lhs,
+	   const basic_string <charT, traits, Allocator>& rhs)
+{
+  return (lhs.compare (rhs) > 0);
+}
+
+template <class charT, class traits, class Allocator>
+inline bool
+operator<= (const basic_string <charT, traits, Allocator>& lhs,
+	    const basic_string <charT, traits, Allocator>& rhs)
+{
+  return (lhs.compare (rhs) <= 0);
+}
+
+template <class charT, class traits, class Allocator>
+inline bool
+operator>= (const basic_string <charT, traits, Allocator>& lhs,
+	    const basic_string <charT, traits, Allocator>& rhs)
+{
+  return (lhs.compare (rhs) >= 0);
+}
+
+class istream; class ostream;
+template <class charT, class traits, class Allocator> istream&
+operator>> (istream&, basic_string <charT, traits, Allocator>&);
+template <class charT, class traits, class Allocator> ostream&
+operator<< (ostream&, const basic_string <charT, traits, Allocator>&);
+template <class charT, class traits, class Allocator> istream&
+getline (istream&, basic_string <charT, traits, Allocator>&, charT delim = '\n');
+
+} // extern "C++"
+
+#include <std/bastring.cc>
+
+#endif
diff --git a/gnu/egcs/libstdc++/std/complext.cc b/gnu/egcs/libstdc++/std/complext.cc
new file mode 100644
index 00000000000..d50bf0871f6
--- /dev/null
+++ b/gnu/egcs/libstdc++/std/complext.cc
@@ -0,0 +1,273 @@
+// Member templates for the -*- C++ -*- complex number classes.
+// Copyright (C) 1994 Free Software Foundation
+
+// This file is part of the GNU ANSI 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, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+// As a special exception, if you link this library with files
+// compiled with a GNU compiler to produce an executable, this does not 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.
+
+// Written by Jason Merrill based upon the specification in the 27 May 1994
+// C++ working paper, ANSI document X3J16/94-0098.
+
+#include <complex>
+
+extern "C++" {
+template <class FLOAT> complex<FLOAT>
+cos (const complex<FLOAT>& x)
+{
+  return complex<FLOAT> (cos (real (x)) * cosh (imag (x)),
+			   - sin (real (x)) * sinh (imag (x)));
+}
+
+template <class FLOAT> complex<FLOAT>
+cosh (const complex<FLOAT>& x)
+{
+  return complex<FLOAT> (cosh (real (x)) * cos (imag (x)),
+			   sinh (real (x)) * sin (imag (x)));
+}
+
+template <class FLOAT> complex<FLOAT>
+exp (const complex<FLOAT>& x)
+{
+  return polar (FLOAT (exp (real (x))), imag (x));
+}
+
+template <class FLOAT> complex<FLOAT>
+log (const complex<FLOAT>& x)
+{
+  return complex<FLOAT> (log (abs (x)), arg (x));
+}
+
+template <class FLOAT> complex<FLOAT>
+pow (const complex<FLOAT>& x, const complex<FLOAT>& y)
+{
+  FLOAT logr = log (abs (x));
+  FLOAT t = arg (x);
+
+  return polar (FLOAT (exp (logr * real (y) - imag (y) * t)),
+		FLOAT (imag (y) * logr + real (y) * t));
+}
+
+template <class FLOAT> complex<FLOAT>
+pow (const complex<FLOAT>& x, FLOAT y)
+{
+  return exp (FLOAT (y) * log (x));
+}
+
+template <class FLOAT> complex<FLOAT>
+pow (FLOAT x, const complex<FLOAT>& y)
+{
+  return exp (y * FLOAT (log (x)));
+}
+
+template <class FLOAT> complex<FLOAT>
+sin (const complex<FLOAT>& x)
+{
+  return complex<FLOAT> (sin (real (x)) * cosh (imag (x)),
+			   cos (real (x)) * sinh (imag (x)));
+}
+
+template <class FLOAT> complex<FLOAT>
+sinh (const complex<FLOAT>& x)
+{
+  return complex<FLOAT> (sinh (real (x)) * cos (imag (x)),
+			   cosh (real (x)) * sin (imag (x)));
+}
+
+#include <iostream.h>
+
+template <class FLOAT> istream&
+operator >> (istream& is, complex<FLOAT>& x)
+{
+  FLOAT re, im = 0;
+  char ch = 0;
+
+  if (is.ipfx0 ())
+    {
+      if (is.peek () == '(')
+	is >> ch;
+      is >> re;
+      if (ch == '(')
+	{
+	  is >> ch;
+	  if (ch == ',')
+	    is >> im >> ch;
+	}
+    }
+  is.isfx ();
+
+  if (ch != 0 && ch != ')')
+    is.setstate (ios::failbit);
+  else if (is.good ())
+    x = complex<FLOAT> (re, im);
+
+  return is;
+}
+
+template <class FLOAT> ostream&
+operator << (ostream& os, const complex<FLOAT>& x)
+{
+  return os << '(' << real (x) << ',' << imag (x) << ')';
+}
+
+// The code below is adapted from f2c's libF77, and is subject to this
+// copyright:
+
+/****************************************************************
+Copyright 1990, 1991, 1992, 1993 by AT&T Bell Laboratories and Bellcore.
+
+Permission to use, copy, modify, and distribute this software
+and its documentation for any purpose and without fee is hereby
+granted, provided that the above copyright notice appear in all
+copies and that both that the copyright notice and this
+permission notice and warranty disclaimer appear in supporting
+documentation, and that the names of AT&T Bell Laboratories or
+Bellcore or any of their entities not be used in advertising or
+publicity pertaining to distribution of the software without
+specific, written prior permission.
+
+AT&T and Bellcore disclaim all warranties with regard to this
+software, including all implied warranties of merchantability
+and fitness.  In no event shall AT&T or Bellcore be liable for
+any special, indirect or consequential damages or any damages
+whatsoever resulting from loss of use, data or profits, whether
+in an action of contract, negligence or other tortious action,
+arising out of or in connection with the use or performance of
+this software.
+****************************************************************/
+
+template <class FLOAT> complex<FLOAT>&
+__doadv (complex<FLOAT>* ths, const complex<FLOAT>& y)
+{
+  FLOAT ar = abs (y.re);
+  FLOAT ai = abs (y.im);
+  FLOAT nr, ni;
+  FLOAT t, d;
+  if (ar <= ai)
+    {
+      t = y.re / y.im;
+      d = y.im * (1 + t*t);
+      nr = (ths->re * t + ths->im) / d;
+      ni = (ths->im * t - ths->re) / d;
+    }
+  else
+    {
+      t = y.im / y.re;
+      d = y.re * (1 + t*t);
+      nr = (ths->re + ths->im * t) / d;
+      ni = (ths->im - ths->re * t) / d;
+    }
+  ths->re = nr;
+  ths->im = ni;
+  return *ths;
+}
+
+template <class FLOAT> complex<FLOAT>
+operator / (const complex<FLOAT>& x, const complex<FLOAT>& y)
+{
+  FLOAT ar = abs (real (y));
+  FLOAT ai = abs (imag (y));
+  FLOAT nr, ni;
+  FLOAT t, d;
+  if (ar <= ai)
+    {
+      t = real (y) / imag (y);
+      d = imag (y) * (1 + t*t);
+      nr = (real (x) * t + imag (x)) / d;
+      ni = (imag (x) * t - real (x)) / d;
+    }
+  else
+    {
+      t = imag (y) / real (y);
+      d = real (y) * (1 + t*t);
+      nr = (real (x) + imag (x) * t) / d;
+      ni = (imag (x) - real (x) * t) / d;
+    }
+  return complex<FLOAT> (nr, ni);
+}
+
+template <class FLOAT> complex<FLOAT>
+operator / (FLOAT x, const complex<FLOAT>& y)
+{
+  FLOAT ar = abs (real (y));
+  FLOAT ai = abs (imag (y));
+  FLOAT nr, ni;
+  FLOAT t, d;
+  if (ar <= ai)
+    {
+      t = real (y) / imag (y);
+      d = imag (y) * (1 + t*t);
+      nr = x * t / d;
+      ni = -x / d;
+    }
+  else
+    {
+      t = imag (y) / real (y);
+      d = real (y) * (1 + t*t);
+      nr = x / d;
+      ni = -x * t / d;
+    }
+  return complex<FLOAT> (nr, ni);
+}
+
+template <class FLOAT> complex<FLOAT>
+pow (const complex<FLOAT>& xin, int y)
+{
+  if (y == 0)
+    return complex<FLOAT> (1.0);
+  complex<FLOAT> r (1.0);
+  complex<FLOAT> x (xin);
+  if (y < 0)
+    {
+      y = -y;
+      x = 1/x;
+    }
+  for (;;)
+    {
+      if (y & 1)
+	r *= x;
+      if (y >>= 1)
+	x *= x;
+      else
+	return r;
+    }
+}
+
+template <class FLOAT> complex<FLOAT>
+sqrt (const complex<FLOAT>& x)
+{
+  FLOAT r = abs (x);
+  FLOAT nr, ni;
+  if (r == 0.0)
+    nr = ni = r;
+  else if (real (x) > 0)
+    {
+      nr = sqrt (0.5 * (r + real (x)));
+      ni = imag (x) / nr / 2;
+    }
+  else
+    {
+      ni = sqrt (0.5 * (r - real (x)));
+      if (imag (x) < 0)
+	ni = - ni;
+      nr = imag (x) / ni / 2;
+    }
+  return complex<FLOAT> (nr, ni); 
+}
+} // extern "C++"
diff --git a/gnu/egcs/libstdc++/std/complext.h b/gnu/egcs/libstdc++/std/complext.h
new file mode 100644
index 00000000000..6c55037bf94
--- /dev/null
+++ b/gnu/egcs/libstdc++/std/complext.h
@@ -0,0 +1,400 @@
+// The template and inlines for the -*- C++ -*- complex number classes.
+// Copyright (C) 1994 Free Software Foundation
+
+// This file is part of the GNU ANSI 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, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+// As a special exception, if you link this library with files compiled
+// with a GNU compiler to produce an executable, this does not 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.
+
+// Written by Jason Merrill based upon the specification in the 27 May 1994
+// C++ working paper, ANSI document X3J16/94-0098.
+
+#ifndef __COMPLEXT__
+#define __COMPLEXT__
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include <cmath>
+
+#if ! defined (__GNUG__) && ! defined (__attribute__)
+#define __attribute__(foo) /* Ignore.  */
+#endif
+
+class istream;
+class ostream;
+
+extern "C++" {
+template <class _FLT> class complex;
+template <class _FLT> complex<_FLT>&
+  __doapl (complex<_FLT>* ths, const complex<_FLT>& r);
+template <class _FLT> complex<_FLT>&
+  __doami (complex<_FLT>* ths, const complex<_FLT>& r);
+template <class _FLT> complex<_FLT>&
+  __doaml (complex<_FLT>* ths, const complex<_FLT>& r);
+template <class _FLT> complex<_FLT>&
+  __doadv (complex<_FLT>* ths, const complex<_FLT>& r);
+
+template <class _FLT>
+class complex
+{
+public:
+  complex (_FLT r = 0, _FLT i = 0): re (r), im (i) { }
+  complex& operator += (const complex&);
+  complex& operator -= (const complex&);
+  complex& operator *= (const complex&);
+  complex& operator /= (const complex&);
+  _FLT real () const { return re; }
+  _FLT imag () const { return im; }
+private:
+  _FLT re, im;
+
+  friend complex& __doapl<> (complex *, const complex&);
+  friend complex& __doami<> (complex *, const complex&);
+  friend complex& __doaml<> (complex *, const complex&);
+  friend complex& __doadv<> (complex *, const complex&);
+};
+
+// Declare specializations.
+class complex<float>;
+class complex<double>;
+class complex<long double>;
+
+template <class _FLT>
+inline complex<_FLT>&
+__doapl (complex<_FLT>* ths, const complex<_FLT>& r)
+{
+  ths->re += r.re;
+  ths->im += r.im;
+  return *ths;
+}
+template <class _FLT>
+inline complex<_FLT>&
+complex<_FLT>::operator += (const complex<_FLT>& r)
+{
+  return __doapl (this, r);
+}
+
+template <class _FLT>
+inline complex<_FLT>&
+__doami (complex<_FLT>* ths, const complex<_FLT>& r)
+{
+  ths->re -= r.re;
+  ths->im -= r.im;
+  return *ths;
+}
+template <class _FLT>
+inline complex<_FLT>&
+complex<_FLT>::operator -= (const complex<_FLT>& r)
+{
+  return __doami (this, r);
+}
+
+template <class _FLT>
+inline complex<_FLT>&
+__doaml (complex<_FLT>* ths, const complex<_FLT>& r)
+{
+  _FLT f = ths->re * r.re - ths->im * r.im;
+  ths->im = ths->re * r.im + ths->im * r.re;
+  ths->re = f;
+  return *ths;
+}
+template <class _FLT>
+inline complex<_FLT>&
+complex<_FLT>::operator *= (const complex<_FLT>& r)
+{
+  return __doaml (this, r);
+}
+
+template <class _FLT>
+inline complex<_FLT>&
+complex<_FLT>::operator /= (const complex<_FLT>& r)
+{
+  return __doadv (this, r);
+}
+
+template <class _FLT> inline _FLT
+imag (const complex<_FLT>& x) __attribute__ ((const));
+
+template <class _FLT> inline _FLT
+imag (const complex<_FLT>& x)
+{
+  return x.imag ();
+}
+
+template <class _FLT> inline _FLT
+real (const complex<_FLT>& x) __attribute__ ((const));
+
+template <class _FLT> inline _FLT
+real (const complex<_FLT>& x)
+{
+  return x.real ();
+}
+
+template <class _FLT> inline complex<_FLT>
+operator + (const complex<_FLT>& x, const complex<_FLT>& y) __attribute__ ((const));
+
+template <class _FLT> inline complex<_FLT>
+operator + (const complex<_FLT>& x, const complex<_FLT>& y)
+{
+  return complex<_FLT> (real (x) + real (y), imag (x) + imag (y));
+}
+
+template <class _FLT> inline complex<_FLT>
+operator + (const complex<_FLT>& x, _FLT y) __attribute__ ((const));
+
+template <class _FLT> inline complex<_FLT>
+operator + (const complex<_FLT>& x, _FLT y)
+{
+  return complex<_FLT> (real (x) + y, imag (x));
+}
+
+template <class _FLT> inline complex<_FLT>
+operator + (_FLT x, const complex<_FLT>& y) __attribute__ ((const));
+
+template <class _FLT> inline complex<_FLT>
+operator + (_FLT x, const complex<_FLT>& y)
+{
+  return complex<_FLT> (x + real (y), imag (y));
+}
+
+template <class _FLT> inline complex<_FLT>
+operator - (const complex<_FLT>& x, const complex<_FLT>& y) __attribute__ ((const));
+
+template <class _FLT> inline complex<_FLT>
+operator - (const complex<_FLT>& x, const complex<_FLT>& y)
+{
+  return complex<_FLT> (real (x) - real (y), imag (x) - imag (y));
+}
+
+template <class _FLT> inline complex<_FLT>
+operator - (const complex<_FLT>& x, _FLT y) __attribute__ ((const));
+
+template <class _FLT> inline complex<_FLT>
+operator - (const complex<_FLT>& x, _FLT y)
+{
+  return complex<_FLT> (real (x) - y, imag (x));
+}
+
+template <class _FLT> inline complex<_FLT>
+operator - (_FLT x, const complex<_FLT>& y) __attribute__ ((const));
+
+template <class _FLT> inline complex<_FLT>
+operator - (_FLT x, const complex<_FLT>& y)
+{
+  return complex<_FLT> (x - real (y), - imag (y));
+}
+
+template <class _FLT> inline complex<_FLT>
+operator * (const complex<_FLT>& x, const complex<_FLT>& y) __attribute__ ((const));
+
+template <class _FLT> inline complex<_FLT>
+operator * (const complex<_FLT>& x, const complex<_FLT>& y)
+{
+  return complex<_FLT> (real (x) * real (y) - imag (x) * imag (y),
+			   real (x) * imag (y) + imag (x) * real (y));
+}
+
+template <class _FLT> inline complex<_FLT>
+operator * (const complex<_FLT>& x, _FLT y) __attribute__ ((const));
+
+template <class _FLT> inline complex<_FLT>
+operator * (const complex<_FLT>& x, _FLT y)
+{
+  return complex<_FLT> (real (x) * y, imag (x) * y);
+}
+
+template <class _FLT> inline complex<_FLT>
+operator * (_FLT x, const complex<_FLT>& y) __attribute__ ((const));
+
+template <class _FLT> inline complex<_FLT>
+operator * (_FLT x, const complex<_FLT>& y)
+{
+  return complex<_FLT> (x * real (y), x * imag (y));
+}
+
+template <class _FLT> complex<_FLT>
+operator / (const complex<_FLT>& x, _FLT y) __attribute__ ((const));
+
+template <class _FLT> complex<_FLT>
+operator / (const complex<_FLT>& x, _FLT y)
+{
+  return complex<_FLT> (real (x) / y, imag (x) / y);
+}
+
+template <class _FLT> inline complex<_FLT>
+operator + (const complex<_FLT>& x) __attribute__ ((const));
+
+template <class _FLT> inline complex<_FLT>
+operator + (const complex<_FLT>& x)
+{
+  return x;
+}
+
+template <class _FLT> inline complex<_FLT>
+operator - (const complex<_FLT>& x) __attribute__ ((const));
+
+template <class _FLT> inline complex<_FLT>
+operator - (const complex<_FLT>& x)
+{
+  return complex<_FLT> (-real (x), -imag (x));
+}
+
+template <class _FLT> inline bool
+operator == (const complex<_FLT>& x, const complex<_FLT>& y) __attribute__ ((const));
+
+template <class _FLT> inline bool
+operator == (const complex<_FLT>& x, const complex<_FLT>& y)
+{
+  return real (x) == real (y) && imag (x) == imag (y);
+}
+
+template <class _FLT> inline bool
+operator == (const complex<_FLT>& x, _FLT y) __attribute__ ((const));
+
+template <class _FLT> inline bool
+operator == (const complex<_FLT>& x, _FLT y)
+{
+  return real (x) == y && imag (x) == 0;
+}
+
+template <class _FLT> inline bool
+operator == (_FLT x, const complex<_FLT>& y) __attribute__ ((const));
+
+template <class _FLT> inline bool
+operator == (_FLT x, const complex<_FLT>& y)
+{
+  return x == real (y) && imag (y) == 0;
+}
+
+template <class _FLT> inline bool
+operator != (const complex<_FLT>& x, const complex<_FLT>& y) __attribute__ ((const));
+
+template <class _FLT> inline bool
+operator != (const complex<_FLT>& x, const complex<_FLT>& y)
+{
+  return real (x) != real (y) || imag (x) != imag (y);
+}
+
+template <class _FLT> inline bool
+operator != (const complex<_FLT>& x, _FLT y) __attribute__ ((const));
+
+template <class _FLT> inline bool
+operator != (const complex<_FLT>& x, _FLT y)
+{
+  return real (x) != y || imag (x) != 0;
+}
+
+template <class _FLT> inline bool
+operator != (_FLT x, const complex<_FLT>& y) __attribute__ ((const));
+
+template <class _FLT> inline bool
+operator != (_FLT x, const complex<_FLT>& y)
+{
+  return x != real (y) || imag (y) != 0;
+}
+
+// Some targets don't provide a prototype for hypot when -ansi.
+extern "C" double hypot (double, double) __attribute__ ((const));
+
+template <class _FLT> inline _FLT
+abs (const complex<_FLT>& x) __attribute__ ((const));
+
+template <class _FLT> inline _FLT
+abs (const complex<_FLT>& x)
+{
+  return hypot (real (x), imag (x));
+}
+
+template <class _FLT> inline _FLT
+arg (const complex<_FLT>& x) __attribute__ ((const));
+
+template <class _FLT> inline _FLT
+arg (const complex<_FLT>& x)
+{
+  return atan2 (imag (x), real (x));
+}
+
+template <class _FLT> inline complex<_FLT>
+polar (_FLT r, _FLT t) __attribute__ ((const));
+
+template <class _FLT> inline complex<_FLT>
+polar (_FLT r, _FLT t)
+{
+  return complex<_FLT> (r * cos (t), r * sin (t));
+}
+
+template <class _FLT> inline complex<_FLT>
+conj (const complex<_FLT>& x)  __attribute__ ((const));
+
+template <class _FLT> inline complex<_FLT>
+conj (const complex<_FLT>& x) 
+{
+  return complex<_FLT> (real (x), -imag (x));
+}
+
+template <class _FLT> inline _FLT
+norm (const complex<_FLT>& x) __attribute__ ((const));
+
+template <class _FLT> inline _FLT
+norm (const complex<_FLT>& x)
+{
+  return real (x) * real (x) + imag (x) * imag (x);
+}
+
+// Declarations of templates in complext.ccI
+
+template <class _FLT> complex<_FLT>
+  operator / (const complex<_FLT>&, const complex<_FLT>&) __attribute__ ((const));
+template <class _FLT> complex<_FLT>
+  operator / (_FLT, const complex<_FLT>&) __attribute__ ((const));
+template <class _FLT> complex<_FLT>
+  cos (const complex<_FLT>&) __attribute__ ((const));
+template <class _FLT> complex<_FLT>
+  cosh (const complex<_FLT>&) __attribute__ ((const));
+template <class _FLT> complex<_FLT>
+  exp (const complex<_FLT>&) __attribute__ ((const));
+template <class _FLT> complex<_FLT>
+  log (const complex<_FLT>&) __attribute__ ((const));
+template <class _FLT> complex<_FLT>
+  pow (const complex<_FLT>&, const complex<_FLT>&) __attribute__ ((const));
+template <class _FLT> complex<_FLT>
+  pow (const complex<_FLT>&, _FLT) __attribute__ ((const));
+template <class _FLT> complex<_FLT>
+  pow (const complex<_FLT>&, int) __attribute__ ((const));
+template <class _FLT> complex<_FLT>
+  pow (_FLT, const complex<_FLT>&) __attribute__ ((const));
+template <class _FLT> complex<_FLT>
+  sin (const complex<_FLT>&) __attribute__ ((const));
+template <class _FLT> complex<_FLT>
+  sinh (const complex<_FLT>&) __attribute__ ((const));
+template <class _FLT> complex<_FLT>
+  sqrt (const complex<_FLT>&) __attribute__ ((const));
+
+template <class _FLT> istream& operator >> (istream&, complex<_FLT>&);
+template <class _FLT> ostream& operator << (ostream&, const complex<_FLT>&);
+} // extern "C++"
+
+// Specializations and such
+
+#include <std/fcomplex.h>
+#include <std/dcomplex.h>
+#include <std/ldcomplex.h>
+
+#endif
diff --git a/gnu/egcs/libstdc++/std/dcomplex.h b/gnu/egcs/libstdc++/std/dcomplex.h
new file mode 100644
index 00000000000..5812d9fa7df
--- /dev/null
+++ b/gnu/egcs/libstdc++/std/dcomplex.h
@@ -0,0 +1,91 @@
+// The -*- C++ -*- double_complex class.
+// Copyright (C) 1994 Free Software Foundation
+
+// This file is part of the GNU ANSI 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, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+// As a special exception, if you link this library with files
+// compiled with a GNU compiler to produce an executable, this does not 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.
+
+// Written by Jason Merrill based upon the specification in the 27 May 1994
+// C++ working paper, ANSI document X3J16/94-0098.
+
+#ifndef __DCOMPLEX__
+#define __DCOMPLEX__
+
+#ifdef __GNUG__
+#pragma interface "dcomplex"
+#endif
+
+extern "C++" {
+class complex<double>
+{
+public:
+  complex (double r = 0, double i = 0): re (r), im (i) { }
+  complex (const complex<float>& r): re (r.real ()), im (r.imag ()) { }
+  explicit complex (const complex<long double>& r);
+
+  complex& operator+= (const complex& r) { return __doapl (this, r); }
+  complex& operator-= (const complex& r) { return __doami (this, r); }
+  complex& operator*= (const complex& r) { return __doaml (this, r); }
+  complex& operator/= (const complex& r) { return __doadv (this, r); }
+
+  double real () const { return re; }
+  double imag () const { return im; }
+private:
+  double re, im;
+
+  friend complex& __doapl<> (complex *, const complex&);
+  friend complex& __doami<> (complex *, const complex&);
+  friend complex& __doaml<> (complex *, const complex&);
+  friend complex& __doadv<> (complex *, const complex&);
+
+#ifndef __STRICT_ANSI__
+  friend inline complex operator + (const complex& x, double y)
+    { return operator+<> (x, y); }
+  friend inline complex operator + (double x, const complex& y)
+    { return operator+<> (x, y); }
+  friend inline complex operator - (const complex& x, double y)
+    { return operator-<> (x, y); }
+  friend inline complex operator - (double x, const complex& y)
+    { return operator-<> (x, y); }
+  friend inline complex operator * (const complex& x, double y)
+    { return operator*<> (x, y); }
+  friend inline complex operator * (double x, const complex& y)
+    { return operator*<> (x, y); }
+  friend inline complex operator / (const complex& x, double y)
+    { return operator/<> (x, y); }
+  friend inline complex operator / (double x, const complex& y)
+    { return operator/<> (x, y); }
+  friend inline bool operator == (const complex& x, double y)
+    { return operator==<> (x, y); }
+  friend inline bool operator == (double x, const complex& y)
+    { return operator==<> (x, y); }
+  friend inline bool operator != (const complex& x, double y)
+    { return operator!=<> (x, y); }
+  friend inline bool operator != (double x, const complex& y)
+    { return operator!=<> (x, y); }
+#endif /* __STRICT_ANSI__ */
+};
+
+inline complex<float>::complex (const complex<double>& r)
+: re (r.real ()), im (r.imag ())
+{ }
+} // extern "C++"
+
+#endif
diff --git a/gnu/egcs/libstdc++/std/fcomplex.h b/gnu/egcs/libstdc++/std/fcomplex.h
new file mode 100644
index 00000000000..cd9af1a2e0c
--- /dev/null
+++ b/gnu/egcs/libstdc++/std/fcomplex.h
@@ -0,0 +1,87 @@
+// The -*- C++ -*- float_complex class.
+// Copyright (C) 1994 Free Software Foundation
+
+// This file is part of the GNU ANSI 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, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+// As a special exception, if you link this library with files
+// compiled with a GNU compiler to produce an executable, this does not 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.
+
+// Written by Jason Merrill based upon the specification in the 27 May 1994
+// C++ working paper, ANSI document X3J16/94-0098.
+
+#ifndef __FCOMPLEX__
+#define __FCOMPLEX__
+
+#ifdef __GNUG__
+#pragma interface "fcomplex"
+#endif
+
+extern "C++" {
+class complex<float>
+{
+public:
+  complex (float r = 0, float i = 0): re (r), im (i) { }
+  explicit complex (const complex<double>& r);
+  explicit complex (const complex<long double>& r);
+
+  complex& operator+= (const complex& r) { return __doapl (this, r); }
+  complex& operator-= (const complex& r) { return __doami (this, r); }
+  complex& operator*= (const complex& r) { return __doaml (this, r); }
+  complex& operator/= (const complex& r) { return __doadv (this, r); }
+
+  float real () const { return re; }
+  float imag () const { return im; }
+private:
+  float re, im;
+
+  friend complex& __doapl<> (complex *, const complex&);
+  friend complex& __doami<> (complex *, const complex&);
+  friend complex& __doaml<> (complex *, const complex&);
+  friend complex& __doadv<> (complex *, const complex&);
+
+#ifndef __STRICT_ANSI__
+  friend inline complex operator + (const complex& x, float y)
+    { return operator+<> (x, y); }
+  friend inline complex operator + (float x, const complex& y)
+    { return operator+<> (x, y); }
+  friend inline complex operator - (const complex& x, float y)
+    { return operator-<> (x, y); }
+  friend inline complex operator - (float x, const complex& y)
+    { return operator-<> (x, y); }
+  friend inline complex operator * (const complex& x, float y)
+    { return operator*<> (x, y); }
+  friend inline complex operator * (float x, const complex& y)
+    { return operator*<> (x, y); }
+  friend inline complex operator / (const complex& x, float y)
+    { return operator/<> (x, y); }
+  friend inline complex operator / (float x, const complex& y)
+    { return operator/<> (x, y); }
+  friend inline bool operator == (const complex& x, float y)
+    { return operator==<> (x, y); }
+  friend inline bool operator == (float x, const complex& y)
+    { return operator==<> (x, y); }
+  friend inline bool operator != (const complex& x, float y)
+    { return operator!=<> (x, y); }
+  friend inline bool operator != (float x, const complex& y)
+    { return operator!=<> (x, y); }
+#endif /* __STRICT_ANSI__ */
+};
+} // extern "C++"
+
+#endif
diff --git a/gnu/egcs/libstdc++/std/ldcomplex.h b/gnu/egcs/libstdc++/std/ldcomplex.h
new file mode 100644
index 00000000000..bc91fa422bf
--- /dev/null
+++ b/gnu/egcs/libstdc++/std/ldcomplex.h
@@ -0,0 +1,95 @@
+// The -*- C++ -*- long_double_complex class.
+// Copyright (C) 1994 Free Software Foundation
+
+// This file is part of the GNU ANSI 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, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+// As a special exception, if you link this library with files
+// compiled with a GNU compiler to produce an executable, this does not 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.
+
+// Written by Jason Merrill based upon the specification in the 27 May 1994
+// C++ working paper, ANSI document X3J16/94-0098.
+
+#ifndef __LDCOMPLEX__
+#define __LDCOMPLEX__
+
+#ifdef __GNUG__
+#pragma interface "ldcomplex"
+#endif
+
+extern "C++" {
+class complex<long double>
+{
+public:
+  complex (long double r = 0, long double i = 0): re (r), im (i) { }
+  complex (const complex<float>& r): re (r.real ()), im (r.imag ()) { }
+  complex (const complex<double>& r): re (r.real ()), im (r.imag ()) { }
+
+  complex& operator+= (const complex& r) { return __doapl (this, r); }
+  complex& operator-= (const complex& r) { return __doami (this, r); }
+  complex& operator*= (const complex& r) { return __doaml (this, r); }
+  complex& operator/= (const complex& r) { return __doadv (this, r); }
+
+  long double real () const { return re; }
+  long double imag () const { return im; }
+private:
+  long double re, im;
+
+  friend complex& __doapl<> (complex *, const complex&);
+  friend complex& __doami<> (complex *, const complex&);
+  friend complex& __doaml<> (complex *, const complex&);
+  friend complex& __doadv<> (complex *, const complex&);
+
+#ifndef __STRICT_ANSI__
+  friend inline complex operator + (const complex& x, long double y)
+    { return operator+<> (x, y); }
+  friend inline complex operator + (long double x, const complex& y)
+    { return operator+<> (x, y); }
+  friend inline complex operator - (const complex& x, long double y)
+    { return operator-<> (x, y); }
+  friend inline complex operator - (long double x, const complex& y)
+    { return operator-<> (x, y); }
+  friend inline complex operator * (const complex& x, long double y)
+    { return operator*<> (x, y); }
+  friend inline complex operator * (long double x, const complex& y)
+    { return operator*<> (x, y); }
+  friend inline complex operator / (const complex& x, long double y)
+    { return operator/<> (x, y); }
+  friend inline complex operator / (long double x, const complex& y)
+    { return operator/<> (x, y); }
+  friend inline bool operator == (const complex& x, long double y)
+    { return operator==<> (x, y); }
+  friend inline bool operator == (long double x, const complex& y)
+    { return operator==<> (x, y); }
+  friend inline bool operator != (const complex& x, long double y)
+    { return operator!=<> (x, y); }
+  friend inline bool operator != (long double x, const complex& y)
+    { return operator!=<> (x, y); }
+#endif /* __STRICT_ANSI__ */
+};
+
+inline complex<float>::complex (const complex<long double>& r)
+: re (r.real ()), im (r.imag ())
+{ }
+
+inline complex<double>::complex (const complex<long double>& r)
+: re (r.real ()), im (r.imag ())
+{ }
+} // extern "C++"
+
+#endif
diff --git a/gnu/egcs/libstdc++/std/straits.h b/gnu/egcs/libstdc++/std/straits.h
new file mode 100644
index 00000000000..c80e7ab7a68
--- /dev/null
+++ b/gnu/egcs/libstdc++/std/straits.h
@@ -0,0 +1,161 @@
+// Character traits template for the -*- C++ -*- string classes.
+// Copyright (C) 1994 Free Software Foundation
+
+// This file is part of the GNU ANSI 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, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+// As a special exception, if you link this library with files
+// compiled with a GNU compiler to produce an executable, this does not 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.
+
+// Written by Jason Merrill based upon the specification by Takanori Adachi
+// in ANSI X3J16/94-0013R2.
+
+#ifndef __STRING_CHAR_TRAITS__
+#define __STRING_CHAR_TRAITS__
+
+#ifdef __GNUG__
+// For string_char_traits <char>
+#pragma interface "std/straits.h"
+#endif
+
+#include <cstddef>
+
+extern "C++" {
+template <class charT>
+struct string_char_traits {
+  typedef charT char_type; // for users to acquire the basic character type
+
+  // constraints
+
+  static void assign (char_type& c1, const char_type& c2)
+    { c1 = c2; }
+  static bool eq (const char_type& c1, const char_type& c2)
+    { return (c1 == c2); }
+  static bool ne (const char_type& c1, const char_type& c2)
+    { return !(c1 == c2); }
+  static bool lt (const char_type& c1, const char_type& c2)
+    { return (c1 < c2); }
+  static char_type eos () { return char_type(); } // the null character
+  static bool is_del(char_type a) { return 0; }
+  // characteristic function for delimiters of charT
+  
+  // speed-up functions
+
+  static int compare (const char_type* s1, const char_type* s2, size_t n)
+    {
+      size_t i;
+      for (i = 0; i < n; ++i)
+	if (ne (s1[i], s2[i]))
+	  return lt (s1[i], s2[i]) ? -1 : 1;
+
+      return 0;
+    }
+    
+  static size_t length (const char_type* s)
+    {
+      size_t l = 0;
+      while (ne (*s++, eos ()))
+	++l;
+      return l;
+    }
+
+  static char_type* copy (char_type* s1, const char_type* s2, size_t n)
+    {
+      for (; n--; )
+	assign (s1[n], s2[n]);
+      return s1;
+    }
+
+  static char_type* move (char_type* s1, const char_type* s2, size_t n)
+    {
+      char_type a[n];
+      size_t i;
+      for (i = 0; i < n; ++i)
+	assign (a[i], s2[i]);
+      for (i = 0; i < n; ++i)
+	assign (s1[i], a[i]);
+      return s1;
+    }
+
+  static char_type* set (char_type* s1, const char_type& c, size_t n)
+    {
+      for (; n--; )
+	assign (s1[n], c);
+      return s1;
+    }
+};
+
+class istream;
+class ostream;
+#include <cctype>
+#include <cstring>
+
+struct string_char_traits <char> {
+  typedef char char_type;
+
+  static void assign (char_type& c1, const char_type& c2)
+    { c1 = c2; }
+  static bool eq (const char_type & c1, const char_type& c2)
+    { return (c1 == c2); }
+  static bool ne (const char_type& c1, const char_type& c2)
+    { return (c1 != c2); }
+  static bool lt (const char_type& c1, const char_type& c2)
+    { return (c1 < c2); }
+  static char_type eos () { return 0; }
+  static bool is_del(char_type a) { return isspace(a); }
+
+  static int compare (const char_type* s1, const char_type* s2, size_t n)
+    { return memcmp (s1, s2, n); }
+  static size_t length (const char_type* s)
+    { return strlen (s); }
+  static char_type* copy (char_type* s1, const char_type* s2, size_t n)
+    { return (char_type*) memcpy (s1, s2, n); }
+  static char_type* move (char_type* s1, const char_type* s2, size_t n)
+    { return (char_type*) memmove (s1, s2, n); }
+  static char_type* set (char_type* s1, const char_type& c, size_t n)
+    { return (char_type*) memset (s1, c, n); }
+};
+
+#if 0
+#include <cwctype>
+struct string_char_traits <wchar_t> {
+  typedef wchar_t char_type;
+
+  static void assign (char_type& c1, const char_type& c2)
+    { c1 = c2; }
+  static bool eq (const char_type & c1, const char_type& c2)
+    { return (c1 == c2); }
+  static bool ne (const char_type& c1, const char_type& c2)
+    { return (c1 != c2); }
+  static bool lt (const char_type& c1, const char_type& c2)
+    { return (c1 < c2); }
+  static char_type eos () { return 0; }
+  static bool is_del(char_type a) { return iswspace(a); }
+
+  static int compare (const char_type* s1, const char_type* s2, size_t n)
+    { return wmemcmp (s1, s2, n); }
+  static size_t length (const char_type* s)
+    { return wcslen (s); }
+  static char_type* copy (char_type* s1, const char_type* s2, size_t n)
+    { return wmemcpy (s1, s2, n); }
+  static char_type* set (char_type* s1, const char_type& c, size_t n)
+    { return wmemset (s1, c, n); }
+};
+#endif
+} // extern "C++"
+#endif
diff --git a/gnu/egcs/libstdc++/stdexcept b/gnu/egcs/libstdc++/stdexcept
new file mode 100644
index 00000000000..69e9627d577
--- /dev/null
+++ b/gnu/egcs/libstdc++/stdexcept
@@ -0,0 +1,97 @@
+// Methods for Exception Support for -*- C++ -*-
+// Copyright (C) 1994, 1995, 1997 Free Software Foundation
+
+// This file is part of the GNU ANSI 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, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+// As a special exception, if you link this library with files
+// compiled with a GNU compiler to produce an executable, this does not 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.
+
+// Written by Mike Stump based upon the specification in the 20 September 1994
+// C++ working paper, ANSI document X3J16/94-0158.
+
+#ifndef __STDEXCEPT__
+#define __STDEXCEPT__
+
+#ifdef __GNUG__
+#pragma interface "stdexcept"
+#endif
+
+#include <exception>
+#include <string>
+
+extern "C++" {
+
+namespace std {
+
+class logic_error : public exception {
+  string _what;
+public:
+  logic_error(const string& what_arg): _what (what_arg) { }
+  virtual const char* what () const { return _what.c_str (); }
+};
+
+class domain_error : public logic_error {
+public:
+  domain_error (const string& what_arg): logic_error (what_arg) { }
+};
+
+class invalid_argument : public logic_error {
+public:
+  invalid_argument (const string& what_arg): logic_error (what_arg) { }
+};
+
+class length_error : public logic_error {
+public:
+  length_error (const string& what_arg): logic_error (what_arg) { }
+};
+
+class out_of_range : public logic_error {
+public:
+  out_of_range (const string& what_arg): logic_error (what_arg) { }
+};
+
+class runtime_error : public exception {
+  string _what;
+public:
+  runtime_error(const string& what_arg): _what (what_arg) { }
+  virtual const char* what () const { return _what.c_str (); }
+protected:
+  runtime_error(): exception () { }
+};
+
+class range_error : public runtime_error {
+public:
+  range_error (const string& what_arg): runtime_error (what_arg) { }
+};
+
+class overflow_error : public runtime_error {
+public:
+  overflow_error (const string& what_arg): runtime_error (what_arg) { }
+};
+
+class underflow_error : public runtime_error {
+public:
+  underflow_error (const string& what_arg): runtime_error (what_arg) { }
+};
+
+} // namespace std
+ 
+} // extern "C++"
+
+#endif
diff --git a/gnu/egcs/libstdc++/stdexcepti.cc b/gnu/egcs/libstdc++/stdexcepti.cc
new file mode 100644
index 00000000000..3b03acd63f4
--- /dev/null
+++ b/gnu/egcs/libstdc++/stdexcepti.cc
@@ -0,0 +1,21 @@
+// Implementation file for Exception Support for -*- C++ -*-
+// This file is part of the GNU ANSI C++ Library.
+
+#ifdef __GNUG__
+#pragma implementation "stdexcept"
+#endif
+
+#include <stdexcept>
+
+// Entry points for string.
+
+void
+__out_of_range (const char *s)
+{
+  throw out_of_range (s);
+}
+
+void __length_error (const char *s)
+{
+  throw length_error (s);
+}
diff --git a/gnu/egcs/libstdc++/stl.h b/gnu/egcs/libstdc++/stl.h
new file mode 100644
index 00000000000..4b270742c9c
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl.h
@@ -0,0 +1,15 @@
+// -*- C++ -*- compatibility header.
+// This file is part of the GNU ANSI C++ Library.
+
+#include <algorithm>
+#include <deque>
+#include <functional>
+#include <iterator>
+#include <list>
+#include <map>
+#include <memory>
+#include <numeric>
+#include <set>
+#include <stack>
+#include <utility>
+#include <vector>
diff --git a/gnu/egcs/libstdc++/stl/ChangeLog b/gnu/egcs/libstdc++/stl/ChangeLog
new file mode 100644
index 00000000000..10669ea9b4c
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/ChangeLog
@@ -0,0 +1,330 @@
+Mon May 17 03:33:47 1999  Mumit Khan  <khan@xraylith.wisc.edu>
+
+	* stl_config.h (__CYGWIN__): Cygwin newlib RTL lacks drand48.
+
+1999-05-07  Ulrich Drepper  <drepper@cygnus.com>
+
+	* stl_alloc.h: Make it possible to compile with __USE_MALLOC.
+
+Tue Apr 13 00:32:57 1999  Mumit Khan  <khan@xraylith.wisc.edu>
+
+	* stl_config.h (__MINGW32__): Mingw32 RTL lacks drand48.
+
+Sun Apr 11 23:48:30 1999  Jeffrey A Law  (law@cygnus.com)
+
+	* bitset: Re-install Alexandre's lost patch from 1998-11-27.
+
+1999-01-20  Ulrich Drepper  <drepper@cygnus.com>
+
+	* stl_construct.h (__destroy_aux): Use != instead of < for
+	ForwardIterator comparison.
+	Patch by jmaurer@menuett.rhein-main.de (Jens Maurer).
+
+1999-01-20  Mark Mitchell  <mark@markmitchell.com>
+
+	* stl_config.h (__STL_USE_NAMESPACES): Define.
+
+1998-11-27  Alexandre Oliva  <oliva@dcc.unicamp.br>
+
+	* bitset: Explicitly convert basic_string<...>::npos to size_t in
+	default argument to constructor, to avoid parse error at `>'.
+	(__STL_EXPLICIT_FUNCTION_TMPL_ARGS): Replace #if with #ifdef.
+
+1998-11-01  Mark Mitchell  <mark@markmitchell.com>
+
+	* stl_alloc.h (default_alloc_template::_S_free_list): Don't
+	qualify _NFREELISTS.
+
+1998-10-11  Mark Mitchell  <mark@markmitchell.com>
+
+	* stl_config.h (__SGI_STL_USE_AUTO_PTR_CONVERSIONS): Define.
+	* memory (auto_ptr::operator auto_ptr_ref<_Tp1>): Fix typo.
+	(auto_ptr::operator auto_ptr<_Tp1>): Add missing
+	semicolon.
+
+1998-09-03  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* stl_config.h: Define __STL_HAS_WCHAR_T,
+	__STL_MEMBER_TEMPLATE_CLASSES, __STL_HAS_NAMESPACES,
+	__STL_NO_NAMESPACES and __STL_LONG_LONG.
+
+1998-09-02  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* algorithm alloc.h defalloc.h hash_map.h hash_set.h iterator
+	memory pthread_alloc pthread_alloc.h rope ropeimpl.h stl_algo.h
+	stl_algobase.h stl_alloc.h stl_bvector.h stl_config.h
+	stl_construct.h stl_deque.h stl_function.h stl_hash_fun.h
+	stl_hash_map.h stl_hash_set.h stl_hashtable.h stl_heap.h
+	stl_iterator.h stl_list.h stl_map.h stl_multimap.h stl_multiset.h
+	stl_numeric.h stl_pair.h stl_queue.h stl_raw_storage_iter.h
+	stl_relops.h stl_rope.h stl_set.h stl_slist.h stl_stack.h
+	stl_tempbuf.h stl_tree.h stl_uninitialized.h stl_vector.h
+	tempbuf.h type_traits.h: Update to SGI STL 3.11.
+
+Fri Jul 10 15:20:09 1998  Klaus-Georg Adams <Klaus-Georg.Adams@chemie.uni-karlsruhe.de>
+
+	* stl_tempbuf.h (temporary_buffer): Add missing typename.
+	* type_traits.h: update comments.
+
+Sun Jun 28 00:49:42 1998  Jeffrey A Law  (law@cygnus.com)
+
+	* stl_config.h (__STL_PTHREADS): Don't define for glibc 2 if
+	_G_USING_THUNKS is not defined.
+
+1998-04-07 18:32  Ulrich Drepper  <drepper@cygnus.com>
+
+	* stl_hashtable.h (__stl_prime_list): Mark last two numbers as
+	unsigned long since they are otherwise too large for long int on
+	32bit machines.
+
+Fri Feb 20 16:15:05 1998  H.J. Lu  (hjl@gnu.org)
+			  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* ropeimpl.h: Check __STL_PTHREADS instead of _PTHREADS.
+	* stl_alloc.h: Ditto.
+	* stl_config.h: Ditto.
+	* stl_rope.h: Ditto.
+
+	* stl_config.h: include <_G_config.h> if __GNUG__ is defined.
+	(__STL_PTHREADS): Defined if _PTHREADS is defined or
+	__GLIBC__ >= 2.
+
+Tue Jan 27 12:01:25 1998  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* stl_algo.h (__lg): Fix for n == 0.
+
+Sat Nov  8 00:45:17 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* stl_hash_set.h (swap): Fix typo.
+
+Fri Nov  7 10:27:40 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* stl_hashtable.h: Fix typo.
+
+Thu Nov  6 11:19:09 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* stl_algo.h, stl_algobase.h, stl_bvector.h,
+ 	stl_deque.h: Update to October 28 SGI release.
+
+Sun Nov  2 12:14:56 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* algo.h, algobase.h, alloc.h, bvector.h, defalloc.h, deque.h,
+ 	function.h, hash_map.h, hash_set.h, hashtable.h, heap.h, iterator.h,
+ 	list.h, map.h, multimap.h, multiset.h, pair.h, pthread_alloc.h,
+ 	rope.h, ropeimpl.h, set.h, slist.h, stack.h, stl_config.h, tempbuf.h,
+ 	tree.h, type_traits.h, vector.h: Update to October 27 SGI snapshot.
+	* algorithm, deque, functional, hash_map, hash_set, iterator, list,
+ 	map, memory, numeric, pthread_alloc, queue, rope, set, slist, stack,
+ 	stl_algo.h, stl_algobase.h, stl_alloc.h, stl_bvector.h,
+ 	stl_construct.h, stl_deque.h, stl_function.h, stl_hash_fun.h,
+ 	stl_hash_map.h, stl_hash_set.h, stl_hashtable.h, stl_heap.h,
+ 	stl_iterator.h, stl_list.h, stl_map.h, stl_multimap.h, stl_multiset.h,
+ 	stl_numeric.h, stl_pair.h, stl_queue.h, stl_raw_storage_iter.h,
+ 	stl_relops.h, stl_rope.h, stl_set.h, stl_slist.h, stl_stack.h,
+ 	stl_tempbuf.h, stl_tree.h, stl_uninitialized.h, stl_vector.h,
+ 	utility, vector: New files in October 27 SGI snapshot.
+
+Fri Oct 17 19:07:42 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* tree.h, vector.h: Fix accidental divergence from SGI release.
+
+Tue Sep  9 19:47:28 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* algo.h, algobase.h, alloc.h, bvector.h, deque.h, hashtable.h,
+	iterator.h, list.h, rope.h, ropeimpl.h, slist.h, stl_config.h,
+	tree.h, vector.h: Update To September 8 SGI release.
+
+Tue Sep  9 17:38:47 1997  Mark Mitchell  <mmitchell@usa.net>
+
+	* stl_config.h (__STL_MEMBER_TEMPLATES): Enable.
+
+Tue Aug  5 17:06:01 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* deque.h, function.h, hashtable.h, list.h, rope.h, ropeimpl.h,
+	tree.h:  Update to July 31 SGI release.
+
+Fri Jul 18 10:06:56 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* algo.h, defalloc.h, hashtable.h, rope.h, ropeimpl.h, slist.h:
+	Update to June 30 SGI release.
+
+Fri Jul 04 02:17:15 1997  Ulrich Drepper  <drepper@cygnus.com>
+
+	* tree.h (rb_tree): Reverse order of member initializations
+	to prevent warnings.
+
+Sun Jun 15 18:17:21 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* *.h: Update to 6/13 SGI release.
+
+Fri May 23 10:56:18 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* stl_config.h: Add support for exceptions with g++.
+
+	* *.h: Update to 5/8 SGI release.
+
+Thu Apr 24 19:00:23 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* *.h: Update to 3/24 SGI release.
+
+Wed Feb 19 18:19:18 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* *.h: Update to 2/18 SGI release.
+
+	* bool.h: Lose.
+
+Mon Feb 10 16:33:23 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* alloc.h: Don't define __USE_MALLOC for g++.
+	* bool.h: Lose g++ case.
+
+	* *.h: Update to 2/4 SGI release.
+
+Mon Jan 13 14:39:16 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* *.h: Update to 1/8 SGI release.
+
+Mon Sep 30 17:56:43 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* alloc.h (__unlock): Never use __lock_release.
+
+Fri Sep 27 19:03:06 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* alloc.h (__default_alloc_template): lock is a friend.
+
+Thu Sep 19 20:10:37 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	Propagate these changes to new STL code:
+	* tree.h: Rearrange member initializers in rb_tree constructors.
+	* vector.h (insert): Cast iterator difference to size_type to
+        avoid warning.
+
+	* *.h: Update to SGI snapshot (fixed).
+	* *.c, Makefile.in, configure.in: Removed.
+
+Sat Sep 14 09:43:06 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* deque.h, list.h, tree.h: Remove kludge obsoleted by new
+ 	overloading code.
+
+Sat Aug 10 14:59:50 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* tempbuf.cc (__stl_temp_buffer): Align like a pointer.
+
+Wed Jun 26 13:00:44 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* iterator.h: Add default template parameters.
+
+Wed Apr 24 10:45:22 1996  Doug Evans  <dje@blues.cygnus.com>
+
+	* Makefile.in (tempbuf.o,random.o): Add rules for SunOS VPATH.
+
+Fri Apr  5 17:52:31 1996  Per Bothner  <bothner@kalessin.cygnus.com>
+
+	* configure.in (EXTRA_MOSTLYCLEAN):  New, to remove stl.list.
+
+Fri Mar 22 14:58:30 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	Propagate these changes to new STL code:
+	* tree.h: Rearrange member initializers in rb_tree constructors.
+	* vector.h (insert): Cast iterator difference to size_type to
+        avoid warning.
+
+Sun Mar 10 07:49:03 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* deque.h (distance_type): Add overload for g++.
+	From Joe Buck.
+
+Thu Feb 22 14:07:12 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* bool.h: Revert.
+	* algo.h bvector.h deque.h function.h iterator.h list.h
+	pair.h stack.h tree.h vector.h: Wrap #include <bool.h> with
+	#ifndef __GNUG__.
+	* defalloc.h list.h deque.h tree.h: Use __GNUG__ to control
+	workarounds.
+
+Wed Feb 21 17:13:02 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* bool.h (TRUE, FALSE): Define for people expecting the bool.h
+ 	from libg++.  Is this a good idea?
+
+Tue Feb 20 18:40:02 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* algo.h bool.h bvector.h defalloc.h deque.h function.h heap.h
+ 	iterator.h list.h map.h pair.h random.cc stack.h tree.c tree.h
+ 	vector.h: Revert to HP release with workarounds for missing
+ 	overloading functionality.
+	* Makefile.in (STL_OBJECTS): Remove tree.o.
+
+Thu Nov  9 17:05:23 1995  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* algo.h algobase.h bvector.h defalloc.h deque.h function.h heap.h
+ 	iterator.h list.h map.h multimap.h multiset.h pair.h projectn.h
+ 	set.h stack.h tempbuf.h tree.h vector.h: Wrap #include <bool.h>
+ 	with #ifndef __GNUG__.
+
+Thu Nov  2 17:05:44 1995  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* deque.h (deque<T>::insert): Fix merge typo.
+	* vector.h (value_type): Lose.
+
+Thu Nov  2 14:33:47 1995  Per Bothner  <bothner@kalessin.cygnus.com>
+
+	* algo.h, algobase.h, deque.h, function.h, list.h, pair.h, random.cc:
+	Merge in Oct 31 1995 release from HP.
+
+Fri Aug 11 17:11:12 1995  Per Bothner  <bothner@kalessin.cygnus.com>
+
+	* list.h: Avoid duplicate construction and destruction of list_nodes.
+	Patch from Klamer Schutte <klamer@ph.tn.tudelft.nl>.
+
+Fri Aug 11 16:45:18 1995  Per Bothner  <bothner@kalessin.cygnus.com>
+
+	* algo.h, algobase.h, deque.h:  Merged in Jul 12 1995 release from HP.
+
+Mon Jun  5 18:38:56 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* Makefile.in (stl.list): Depend on stamp-picdir.
+
+Wed May 17 02:30:47 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* tree.h: Rearrange member initializers in rb_tree constructors.
+
+	* Update to HP's February 7, 1995 release.
+
+Fri May  5 10:45:31 1995  Mike Stump  <mrs@cygnus.com>
+
+	* random.cc (seed): Move `for' decl out of `for' statement.
+
+Wed Apr 26 13:09:16 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* configure.in (XCXXINCLUDES): Rename.
+
+Wed Mar 29 19:24:56 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* tree.h (insert): Return a value.
+
+	* vector.h (insert): Cast iterator difference to size_type to
+        avoid warning.
+
+Sun Feb 12 09:12:17 1995  Mike Stump  <mrs@cygnus.com>
+
+	* tree.h (rb_tree::max_size): Add definition when using GNU
+	workaround.
+
+Thu Jan 12 01:37:42 1995  deanm@medulla.LABS.TEK.COM (Dean Messing)
+
+	* configure.in (LIBDIR): Set to yes.
+
+Fri Dec 30 18:26:20 1994  Mike Stump  <mrs@cygnus.com>
+
+	* iterator.h: Add default template parameters where possible.
+
+Fri Dec 30 16:29:39 1994  Mike Stump  <mrs@cygnus.com>
+
+	* algo.h: Change rand to __rand to fix make check on linux systems.
+
+Tue Nov 29 15:30:30 1994  Per Bothner  <bothner@kalessin.cygnus.com>
+
+	* Initial check-in, based on HP's October 21, 1994.
diff --git a/gnu/egcs/libstdc++/stl/README b/gnu/egcs/libstdc++/stl/README
new file mode 100644
index 00000000000..c319c08c7a4
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/README
@@ -0,0 +1,13 @@
+This directory contains an SGI release of the C++ Standard Template
+Library, slightly modified to work with g++.
+
+Note that this is based on a pre-Draft Standard for C++.
+Things are likely to change.  For example, the header file names
+are very likely to change.  The Allocator interface will change.  Etc, etc.
+CYGNUS MAKES NO COMMITTMENT (yet) TO SUPPORT BACKWARD COMPATIBILITY FOR STL.
+
+For examples of things that should work, look in the ../tests directory.
+
+DOCUMENTATION:
+See http://www.sgi.com/Technology/STL/ or http://www.dinkumware.com/
+on the World-Wide Web.
diff --git a/gnu/egcs/libstdc++/stl/algo.h b/gnu/egcs/libstdc++/stl/algo.h
new file mode 100644
index 00000000000..1707868c7c4
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/algo.h
@@ -0,0 +1,114 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_ALGO_H
+#define __SGI_STL_ALGO_H
+
+#include <algobase.h>
+#include <tempbuf.h>
+#include <stl_algo.h>
+#include <stl_numeric.h>
+
+#ifdef __STL_USE_NAMESPACES
+
+// Names from <stl_algo.h>
+using __STD::for_each; 
+using __STD::find; 
+using __STD::find_if; 
+using __STD::adjacent_find; 
+using __STD::count; 
+using __STD::count_if; 
+using __STD::search; 
+using __STD::search_n; 
+using __STD::swap_ranges; 
+using __STD::transform; 
+using __STD::replace; 
+using __STD::replace_if; 
+using __STD::replace_copy; 
+using __STD::replace_copy_if; 
+using __STD::generate; 
+using __STD::generate_n; 
+using __STD::remove; 
+using __STD::remove_if; 
+using __STD::remove_copy; 
+using __STD::remove_copy_if; 
+using __STD::unique; 
+using __STD::unique_copy; 
+using __STD::reverse; 
+using __STD::reverse_copy; 
+using __STD::rotate; 
+using __STD::rotate_copy; 
+using __STD::random_shuffle; 
+using __STD::random_sample; 
+using __STD::random_sample_n; 
+using __STD::partition; 
+using __STD::stable_partition; 
+using __STD::sort; 
+using __STD::stable_sort; 
+using __STD::partial_sort; 
+using __STD::partial_sort_copy; 
+using __STD::nth_element; 
+using __STD::lower_bound; 
+using __STD::upper_bound; 
+using __STD::equal_range; 
+using __STD::binary_search; 
+using __STD::merge; 
+using __STD::inplace_merge; 
+using __STD::includes; 
+using __STD::set_union; 
+using __STD::set_intersection; 
+using __STD::set_difference; 
+using __STD::set_symmetric_difference; 
+using __STD::min_element; 
+using __STD::max_element; 
+using __STD::next_permutation; 
+using __STD::prev_permutation; 
+using __STD::find_first_of; 
+using __STD::find_end; 
+using __STD::is_sorted; 
+using __STD::is_heap; 
+
+// Names from stl_heap.h
+using __STD::push_heap;
+using __STD::pop_heap;
+using __STD::make_heap;
+using __STD::sort_heap;
+
+// Names from <stl_numeric.h>
+using __STD::accumulate; 
+using __STD::inner_product; 
+using __STD::partial_sum; 
+using __STD::adjacent_difference; 
+using __STD::power; 
+using __STD::iota; 
+
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_ALGO_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/algobase.h b/gnu/egcs/libstdc++/stl/algobase.h
new file mode 100644
index 00000000000..f35e7af4a97
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/algobase.h
@@ -0,0 +1,71 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_ALGOBASE_H
+#define __SGI_STL_ALGOBASE_H
+
+#ifndef __SGI_STL_PAIR_H
+#include <pair.h>
+#endif
+#ifndef __SGI_STL_ITERATOR_H
+#include <iterator.h>
+#endif
+#ifndef __SGI_STL_INTERNAL_ALGOBASE_H
+#include <stl_algobase.h>
+#endif
+#ifndef __SGI_STL_INTERNAL_UNINITIALIZED_H
+#include <stl_uninitialized.h>
+#endif
+
+#ifdef __STL_USE_NAMESPACES
+
+// Names from stl_algobase.h
+using __STD::iter_swap; 
+using __STD::swap; 
+using __STD::min; 
+using __STD::max; 
+using __STD::copy; 
+using __STD::copy_backward; 
+using __STD::copy_n; 
+using __STD::fill; 
+using __STD::fill_n; 
+using __STD::mismatch; 
+using __STD::equal; 
+using __STD::lexicographical_compare; 
+using __STD::lexicographical_compare_3way; 
+
+// Names from stl_uninitialized.h
+using __STD::uninitialized_copy;
+using __STD::uninitialized_copy_n;
+using __STD::uninitialized_fill;
+using __STD::uninitialized_fill_n;
+
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_ALGOBASE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/algorithm b/gnu/egcs/libstdc++/stl/algorithm
new file mode 100644
index 00000000000..1ba584f06d4
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/algorithm
@@ -0,0 +1,40 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_ALGORITHM
+#define __SGI_STL_ALGORITHM
+
+#include <stl_algobase.h>
+#include <stl_construct.h>
+#include <stl_uninitialized.h>
+#include <stl_tempbuf.h>
+#include <stl_algo.h>
+
+#endif /* __SGI_STL_ALGORITHM */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/alloc.h b/gnu/egcs/libstdc++/stl/alloc.h
new file mode 100644
index 00000000000..f99a862316e
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/alloc.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 1996-1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_ALLOC_H
+#define __SGI_STL_ALLOC_H
+
+#ifndef __STL_CONFIG_H
+#include <stl_config.h>
+#endif
+#ifndef __SGI_STL_INTERNAL_ALLOC_H
+#include <stl_alloc.h>
+#endif
+
+#ifdef __STL_USE_NAMESPACES
+
+using __STD::__malloc_alloc_template; 
+using __STD::malloc_alloc; 
+using __STD::simple_alloc; 
+using __STD::debug_alloc; 
+using __STD::__default_alloc_template; 
+using __STD::alloc; 
+using __STD::single_client_alloc; 
+#ifdef __STL_STATIC_TEMPLATE_MEMBER_BUG
+using __STD::__malloc_alloc_oom_handler; 
+#endif /* __STL_STATIC_TEMPLATE_MEMBER_BUG */
+#ifdef __STL_USE_STD_ALLOCATORS 
+using __STD::allocator;
+#endif /* __STL_USE_STD_ALLOCATORS */
+
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_ALLOC_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/bitset b/gnu/egcs/libstdc++/stl/bitset
new file mode 100644
index 00000000000..e26845ed045
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/bitset
@@ -0,0 +1,1063 @@
+/*
+ * Copyright (c) 1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_BITSET
+#define __SGI_STL_BITSET
+
+// This implementation of bitset<> has a second template parameter,
+// _WordT, which defaults to unsigned long.  *YOU SHOULD NOT USE
+// THIS FEATURE*.  It is experimental, and it may be removed in
+// future releases.
+
+// A bitset of size N, using words of type _WordT, will have
+// N % (sizeof(_WordT) * CHAR_BIT) unused bits.  (They are the high-
+// order bits in the highest word.)  It is a class invariant
+// of class bitset<> that those unused bits are always zero.
+
+// Most of the actual code isn't contained in bitset<> itself, but in the
+// base class _Base_bitset.  The base class works with whole words, not with
+// individual bits.  This allows us to specialize _Base_bitset for the
+// important special case where the bitset is only a single word.
+
+// The C++ standard does not define the precise semantics of operator[].
+// In this implementation the const version of operator[] is equivalent
+// to test(), except that it does no range checking.  The non-const version
+// returns a reference to a bit, again without doing any range checking.
+
+
+#include <stddef.h>     // for size_t
+#include <string>
+#include <stdexcept>    // for invalid_argument, out_of_range, overflow_error
+#include <iostream.h>   // for istream, ostream
+
+#define __BITS_PER_WORDT(__wt) (CHAR_BIT*sizeof(__wt))
+#define __BITSET_WORDS(__n,__wt) \
+ ((__n) < 1 ? 1 : ((__n) + __BITS_PER_WORDT(__wt) - 1)/__BITS_PER_WORDT(__wt))
+
+__STL_BEGIN_NAMESPACE
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1209
+#endif
+
+// structure to aid in counting bits
+template<bool __dummy>
+struct _Bit_count {
+  static unsigned char _S_bit_count[256];
+};
+
+// Mapping from 8 bit unsigned integers to the index of the first one
+// bit:
+template<bool __dummy>
+struct _First_one {
+  static unsigned char _S_first_one[256];
+};
+
+//
+// Base class: general case.
+//
+
+template<size_t _Nw, class _WordT>
+struct _Base_bitset {
+  _WordT _M_w[_Nw];                // 0 is the least significant word.
+
+  _Base_bitset( void ) { _M_do_reset(); }
+
+  _Base_bitset(unsigned long __val);
+
+  static size_t _S_whichword( size_t __pos ) {
+    return __pos / __BITS_PER_WORDT(_WordT);
+  }
+  static size_t _S_whichbyte( size_t __pos ) {
+    return (__pos % __BITS_PER_WORDT(_WordT)) / CHAR_BIT;
+  }
+  static size_t _S_whichbit( size_t __pos ) {
+    return __pos % __BITS_PER_WORDT(_WordT);
+  }
+  static _WordT _S_maskbit( size_t __pos ) {
+    return (static_cast<_WordT>(1)) << _S_whichbit(__pos);
+  }
+
+  _WordT& _M_getword(size_t __pos)       { return _M_w[_S_whichword(__pos)]; }
+  _WordT  _M_getword(size_t __pos) const { return _M_w[_S_whichword(__pos)]; }
+
+  _WordT& _M_hiword()       { return _M_w[_Nw - 1]; }
+  _WordT  _M_hiword() const { return _M_w[_Nw - 1]; }
+
+  void _M_do_and(const _Base_bitset<_Nw,_WordT>& __x) {
+    for ( size_t __i = 0; __i < _Nw; __i++ ) {
+      _M_w[__i] &= __x._M_w[__i];
+    }
+  }
+
+  void _M_do_or(const _Base_bitset<_Nw,_WordT>& __x) {
+    for ( size_t __i = 0; __i < _Nw; __i++ ) {
+      _M_w[__i] |= __x._M_w[__i];
+    }
+  }
+
+  void _M_do_xor(const _Base_bitset<_Nw,_WordT>& __x) {
+    for ( size_t __i = 0; __i < _Nw; __i++ ) {
+      _M_w[__i] ^= __x._M_w[__i];
+    }
+  }
+
+  void _M_do_left_shift(size_t __shift);
+
+  void _M_do_right_shift(size_t __shift);
+
+  void _M_do_flip() {
+    for ( size_t __i = 0; __i < _Nw; __i++ ) {
+      _M_w[__i] = ~_M_w[__i];
+    }
+  }
+
+  void _M_do_set() {
+    for ( size_t __i = 0; __i < _Nw; __i++ ) {
+      _M_w[__i] = ~static_cast<_WordT>(0);
+    }
+  }
+
+  void _M_do_reset() {
+    for ( size_t __i = 0; __i < _Nw; __i++ ) {
+      _M_w[__i] = 0;
+    }
+  }
+
+  bool _M_is_equal(const _Base_bitset<_Nw,_WordT>& __x) const {
+    for (size_t __i = 0; __i < _Nw; ++__i) {
+      if (_M_w[__i] != __x._M_w[__i])
+        return false;
+    }
+    return true;
+  }
+
+  bool _M_is_any() const {
+    for ( size_t __i = 0; __i < __BITSET_WORDS(_Nw,_WordT); __i++ ) {
+      if ( _M_w[__i] != static_cast<_WordT>(0) )
+        return true;
+    }
+    return false;
+  }
+
+  size_t _M_do_count() const {
+    size_t __result = 0;
+    const unsigned char* __byte_ptr = (const unsigned char*)_M_w;
+    const unsigned char* __end_ptr = (const unsigned char*)(_M_w+_Nw);
+
+    while ( __byte_ptr < __end_ptr ) {
+      __result += _Bit_count<true>::_S_bit_count[*__byte_ptr];
+      __byte_ptr++;
+    }
+    return __result;
+  }
+
+  unsigned long _M_do_to_ulong() const;
+
+  // find first "on" bit
+  size_t _M_do_find_first(size_t __not_found) const;
+
+  // find the next "on" bit that follows "prev"
+  size_t _M_do_find_next(size_t __prev, size_t __not_found) const;
+};
+
+//
+// Definitions of non-inline functions from _Base_bitset.
+//
+
+template<size_t _Nw, class _WordT>
+_Base_bitset<_Nw, _WordT>::_Base_bitset(unsigned long __val)
+{
+  _M_do_reset();
+  const size_t __n = min(sizeof(unsigned long)*CHAR_BIT,
+                         __BITS_PER_WORDT(_WordT)*_Nw);
+  for(size_t __i = 0; __i < __n; ++__i, __val >>= 1)
+    if ( __val & 0x1 )
+      _M_getword(__i) |= _S_maskbit(__i);
+}
+
+template<size_t _Nw, class _WordT>
+void _Base_bitset<_Nw, _WordT>::_M_do_left_shift(size_t __shift)
+{
+  if (__shift != 0) {
+    const size_t __wshift = __shift / __BITS_PER_WORDT(_WordT);
+    const size_t __offset = __shift % __BITS_PER_WORDT(_WordT);
+    const size_t __sub_offset = __BITS_PER_WORDT(_WordT) - __offset;
+    size_t __n = _Nw - 1;
+    for ( ; __n > __wshift; --__n)
+      _M_w[__n] = (_M_w[__n - __wshift] << __offset) |
+                (_M_w[__n - __wshift - 1] >> __sub_offset);
+    if (__n == __wshift)
+      _M_w[__n] = _M_w[0] << __offset;
+    for (size_t __n1 = 0; __n1 < __n; ++__n1)
+      _M_w[__n1] = static_cast<_WordT>(0);
+  }
+}
+
+template<size_t _Nw, class _WordT>
+void _Base_bitset<_Nw, _WordT>::_M_do_right_shift(size_t __shift)
+{
+  if (__shift != 0) {
+    const size_t __wshift = __shift / __BITS_PER_WORDT(_WordT);
+    const size_t __offset = __shift % __BITS_PER_WORDT(_WordT);
+    const size_t __sub_offset = __BITS_PER_WORDT(_WordT) - __offset;
+    const size_t __limit = _Nw - __wshift - 1;
+    size_t __n = 0;
+    for ( ; __n < __limit; ++__n)
+      _M_w[__n] = (_M_w[__n + __wshift] >> __offset) |
+                  (_M_w[__n + __wshift + 1] << __sub_offset);
+    _M_w[__limit] = _M_w[_Nw-1] >> __offset;
+    for (size_t __n1 = __limit + 1; __n1 < _Nw; ++__n1)
+      _M_w[__n1] = static_cast<_WordT>(0);
+  }
+}
+
+template<size_t _Nw, class _WordT>
+unsigned long _Base_bitset<_Nw, _WordT>::_M_do_to_ulong() const
+{
+  const overflow_error __overflow("bitset");
+
+  if (sizeof(_WordT) >= sizeof(unsigned long)) {
+    for (size_t __i = 1; __i < _Nw; ++__i)
+      if (_M_w[__i])
+        __STL_THROW(__overflow);
+
+    const _WordT __mask = static_cast<_WordT>(static_cast<unsigned long>(-1));
+    if (_M_w[0] & ~__mask)
+      __STL_THROW(__overflow);
+
+    return static_cast<unsigned long>(_M_w[0] & __mask);
+  }
+  else {                      // sizeof(_WordT) < sizeof(unsigned long).
+    const size_t __nwords =
+      (sizeof(unsigned long) + sizeof(_WordT) - 1) / sizeof(_WordT);
+
+    size_t __min_nwords = __nwords;
+    if (_Nw > __nwords) {
+      for (size_t __i = __nwords; __i < _Nw; ++__i)
+        if (_M_w[__i])
+          __STL_THROW(__overflow);
+    }
+    else
+      __min_nwords = _Nw;
+
+    // If unsigned long is 8 bytes and _WordT is 6 bytes, then an unsigned
+    // long consists of all of one word plus 2 bytes from another word.
+    const size_t __part = sizeof(unsigned long) % sizeof(_WordT);
+
+    if (__part != 0 && __nwords <= _Nw &&
+        (_M_w[__min_nwords - 1] >> ((sizeof(_WordT) - __part) * CHAR_BIT)) != 0)
+      __STL_THROW(__overflow);
+
+    unsigned long __result = 0;
+    for (size_t __i = 0; __i < __min_nwords; ++__i) {
+      __result |= static_cast<unsigned long>(
+         _M_w[__i]) << (__i * sizeof(_WordT) * CHAR_BIT);
+    }
+    return __result;
+  }
+} // End _M_do_to_ulong
+
+template<size_t _Nw, class _WordT>
+size_t _Base_bitset<_Nw, _WordT>::_M_do_find_first(size_t __not_found) const
+{
+  for ( size_t __i = 0; __i < _Nw; __i++ ) {
+    _WordT __thisword = _M_w[__i];
+    if ( __thisword != static_cast<_WordT>(0) ) {
+      // find byte within word
+      for ( size_t __j = 0; __j < sizeof(_WordT); __j++ ) {
+        unsigned char __this_byte
+          = static_cast<unsigned char>(__thisword & (~(unsigned char)0));
+        if ( __this_byte )
+          return __i*__BITS_PER_WORDT(_WordT) + __j*CHAR_BIT +
+            _First_one<true>::_S_first_one[__this_byte];
+
+        __thisword >>= CHAR_BIT;
+      }
+    }
+  }
+  // not found, so return an indication of failure.
+  return __not_found;
+}
+
+template<size_t _Nw, class _WordT>
+size_t
+_Base_bitset<_Nw, _WordT>::_M_do_find_next(size_t __prev,
+                                           size_t __not_found) const
+{
+  // make bound inclusive
+  ++__prev;
+
+  // check out of bounds
+  if ( __prev >= _Nw * __BITS_PER_WORDT(_WordT) )
+    return __not_found;
+
+    // search first word
+  size_t __i = _S_whichword(__prev);
+  _WordT __thisword = _M_w[__i];
+
+    // mask off bits below bound
+  __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);
+
+  if ( __thisword != static_cast<_WordT>(0) ) {
+    // find byte within word
+    // get first byte into place
+    __thisword >>= _S_whichbyte(__prev) * CHAR_BIT;
+    for ( size_t __j = _S_whichbyte(__prev); __j < sizeof(_WordT); __j++ ) {
+      unsigned char __this_byte
+        = static_cast<unsigned char>(__thisword & (~(unsigned char)0));
+      if ( __this_byte )
+        return __i*__BITS_PER_WORDT(_WordT) + __j*CHAR_BIT +
+          _First_one<true>::_S_first_one[__this_byte];
+
+      __thisword >>= CHAR_BIT;
+    }
+  }
+
+  // check subsequent words
+  __i++;
+  for ( ; __i < _Nw; __i++ ) {
+    _WordT __thisword = _M_w[__i];
+    if ( __thisword != static_cast<_WordT>(0) ) {
+      // find byte within word
+      for ( size_t __j = 0; __j < sizeof(_WordT); __j++ ) {
+        unsigned char __this_byte
+          = static_cast<unsigned char>(__thisword & (~(unsigned char)0));
+        if ( __this_byte )
+          return __i*__BITS_PER_WORDT(_WordT) + __j*CHAR_BIT +
+            _First_one<true>::_S_first_one[__this_byte];
+
+        __thisword >>= CHAR_BIT;
+      }
+    }
+  }
+
+  // not found, so return an indication of failure.
+  return __not_found;
+} // end _M_do_find_next
+
+
+// ------------------------------------------------------------
+
+//
+// Base class: specialization for a single word.
+//
+
+template<class _WordT>
+struct _Base_bitset<1, _WordT> {
+  _WordT _M_w;
+
+  _Base_bitset( void ) { _M_do_reset(); }
+
+  _Base_bitset(unsigned long __val);
+
+  static size_t _S_whichword( size_t __pos ) {
+    return __pos / __BITS_PER_WORDT(_WordT);
+  }
+  static size_t _S_whichbyte( size_t __pos ) {
+    return (__pos % __BITS_PER_WORDT(_WordT)) / CHAR_BIT;
+  }
+  static size_t _S_whichbit( size_t __pos ) {
+    return __pos % __BITS_PER_WORDT(_WordT);
+  }
+  static _WordT _S_maskbit( size_t __pos ) {
+    return (static_cast<_WordT>(1)) << _S_whichbit(__pos);
+  }
+
+  _WordT& _M_getword(size_t)       { return _M_w; }
+  _WordT  _M_getword(size_t) const { return _M_w; }
+
+  _WordT& _M_hiword()       { return _M_w; }
+  _WordT  _M_hiword() const { return _M_w; }
+
+  void _M_do_and(const _Base_bitset<1,_WordT>& __x) { _M_w &= __x._M_w; }
+  void _M_do_or(const _Base_bitset<1,_WordT>& __x)  { _M_w |= __x._M_w; }
+  void _M_do_xor(const _Base_bitset<1,_WordT>& __x) { _M_w ^= __x._M_w; }
+  void _M_do_left_shift(size_t __shift)     { _M_w <<= __shift; }
+  void _M_do_right_shift(size_t __shift)    { _M_w >>= __shift; }
+  void _M_do_flip()                       { _M_w = ~_M_w; }
+  void _M_do_set()                        { _M_w = ~static_cast<_WordT>(0); }
+  void _M_do_reset()                      { _M_w = 0; }
+
+  bool _M_is_equal(const _Base_bitset<1,_WordT>& __x) const {
+    return _M_w == __x._M_w;
+  }
+  bool _M_is_any() const {
+    return _M_w != 0;
+  }
+
+  size_t _M_do_count() const {
+    size_t __result = 0;
+    const unsigned char* __byte_ptr = (const unsigned char*)&_M_w;
+    const unsigned char* __end_ptr = ((const unsigned char*)&_M_w)+sizeof(_M_w);
+    while ( __byte_ptr < __end_ptr ) {
+      __result += _Bit_count<true>::_S_bit_count[*__byte_ptr];
+      __byte_ptr++;
+    }
+    return __result;
+  }
+
+  unsigned long _M_do_to_ulong() const {
+    if (sizeof(_WordT) <= sizeof(unsigned long))
+        return static_cast<unsigned long>(_M_w);
+    else {
+      const _WordT __mask = static_cast<_WordT>(static_cast<unsigned long>(-1));
+      if (_M_w & ~__mask)
+        __STL_THROW(overflow_error("bitset"));
+      return static_cast<unsigned long>(_M_w);
+    }
+  }
+
+  size_t _M_do_find_first(size_t __not_found) const;
+
+  // find the next "on" bit that follows "prev"
+  size_t _M_do_find_next(size_t __prev, size_t __not_found) const;
+
+};
+
+//
+// Definitions of non-inline functions from the single-word version of
+//  _Base_bitset.
+//
+
+template <class _WordT>
+_Base_bitset<1, _WordT>::_Base_bitset(unsigned long __val)
+{
+  _M_do_reset();
+  const size_t __n = min(sizeof(unsigned long)*CHAR_BIT,
+                         __BITS_PER_WORDT(_WordT)*_Nw);
+  for(size_t __i = 0; __i < __n; ++__i, __val >>= 1)
+    if ( __val & 0x1 )
+      _M_w |= _S_maskbit(__i);
+}
+
+template <class _WordT>
+size_t _Base_bitset<1, _WordT>::_M_do_find_first(size_t __not_found) const
+{
+  _WordT __thisword = _M_w;
+
+  if ( __thisword != static_cast<_WordT>(0) ) {
+    // find byte within word
+    for ( size_t __j = 0; __j < sizeof(_WordT); __j++ ) {
+      unsigned char __this_byte
+        = static_cast<unsigned char>(__thisword & (~(unsigned char)0));
+      if ( __this_byte )
+        return __j*CHAR_BIT + _First_one<true>::_S_first_one[__this_byte];
+
+      __thisword >>= CHAR_BIT;
+    }
+  }
+  // not found, so return a value that indicates failure.
+  return __not_found;
+}
+
+template <class _WordT>
+size_t
+_Base_bitset<1, _WordT>::_M_do_find_next(size_t __prev,
+                                         size_t __not_found ) const
+{
+  // make bound inclusive
+  ++__prev;
+
+  // check out of bounds
+  if ( __prev >= __BITS_PER_WORDT(_WordT) )
+    return __not_found;
+
+    // search first (and only) word
+  _WordT __thisword = _M_w;
+
+  // mask off bits below bound
+  __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);
+
+  if ( __thisword != static_cast<_WordT>(0) ) {
+    // find byte within word
+    // get first byte into place
+    __thisword >>= _S_whichbyte(__prev) * CHAR_BIT;
+    for ( size_t __j = _S_whichbyte(__prev); __j < sizeof(_WordT); __j++ ) {
+      unsigned char __this_byte
+        = static_cast<unsigned char>(__thisword & (~(unsigned char)0));
+      if ( __this_byte )
+        return __j*CHAR_BIT + _First_one<true>::_S_first_one[__this_byte];
+
+      __thisword >>= CHAR_BIT;
+    }
+  }
+
+  // not found, so return a value that indicates failure.
+  return __not_found;
+} // end _M_do_find_next
+
+//
+// One last specialization: _M_do_to_ulong() and the constructor from
+// unsigned long are very simple if the bitset consists of a single
+// word of type unsigned long.
+//
+
+template<>
+inline unsigned long
+_Base_bitset<1, unsigned long>::_M_do_to_ulong() const { return _M_w; }
+
+template<>
+inline _Base_bitset<1, unsigned long>::_Base_bitset(unsigned long __val) {
+  _M_w = __val;
+}
+
+
+// ------------------------------------------------------------
+// Helper class to zero out the unused high-order bits in the highest word.
+
+template <class _WordT, size_t _Extrabits> struct _Sanitize {
+  static void _M_do_sanitize(_WordT& __val)
+    { __val &= ~((~static_cast<_WordT>(0)) << _Extrabits); }
+};
+
+template <class _WordT> struct _Sanitize<_WordT, 0> {
+  static void _M_do_sanitize(_WordT) {}
+};
+
+// ------------------------------------------------------------
+// Class bitset.
+//   _Nb may be any nonzero number of type size_t.
+//   Type _WordT may be any unsigned integral type.
+
+template<size_t _Nb, class _WordT = unsigned long>
+class bitset : private _Base_bitset<__BITSET_WORDS(_Nb,_WordT), _WordT>
+{
+private:
+  typedef _Base_bitset<__BITSET_WORDS(_Nb,_WordT), _WordT> _Base;
+
+  // Import base's protected interface.  Necessary because of new template
+  // name resolution rules.
+  using _Base::_S_whichword;
+  using _Base::_S_whichbyte;
+  using _Base::_S_whichbit;
+  using _Base::_S_maskbit;
+  using _Base::_M_getword;
+  using _Base::_M_hiword;
+  using _Base::_M_do_and;
+  using _Base::_M_do_or;
+  using _Base::_M_do_xor;
+  using _Base::_M_do_left_shift;
+  using _Base::_M_do_right_shift;
+  using _Base::_M_do_flip;
+  using _Base::_M_do_set;
+  using _Base::_M_do_reset;
+  using _Base::_M_is_equal;
+  using _Base::_M_is_any;
+  using _Base::_M_do_count;
+  using _Base::_M_do_to_ulong;
+  using _Base::_M_do_find_first;
+  using _Base::_M_do_find_next;
+
+private:
+  void _M_do_sanitize() {
+    _Sanitize<_WordT,_Nb%__BITS_PER_WORDT(_WordT) >
+      ::_M_do_sanitize(_M_hiword());
+  }
+
+public:
+
+  // bit reference:
+  class reference {
+    friend class bitset;
+
+    _WordT *_M_wp;
+    size_t _M_bpos;
+
+    // left undefined
+    reference();
+
+    reference( bitset& __b, size_t __pos ) {
+      _M_wp = &__b._M_getword(__pos);
+      _M_bpos = _S_whichbit(__pos);
+    }
+
+  public:
+    ~reference() {}
+
+    // for b[i] = __x;
+    reference& operator=(bool __x) {
+      if ( __x )
+        *_M_wp |= _S_maskbit(_M_bpos);
+      else
+        *_M_wp &= ~_S_maskbit(_M_bpos);
+
+      return *this;
+    }
+
+    // for b[i] = b[__j];
+    reference& operator=(const reference& __j) {
+      if ( (*(__j._M_wp) & _S_maskbit(__j._M_bpos)) )
+        *_M_wp |= _S_maskbit(_M_bpos);
+      else
+        *_M_wp &= ~_S_maskbit(_M_bpos);
+
+      return *this;
+    }
+
+    // flips the bit
+    bool operator~() const { return (*(_M_wp) & _S_maskbit(_M_bpos)) == 0; }
+
+    // for __x = b[i];
+    operator bool() const { return (*(_M_wp) & _S_maskbit(_M_bpos)) != 0; }
+
+    // for b[i].flip();
+    reference& flip() {
+      *_M_wp ^= _S_maskbit(_M_bpos);
+      return *this;
+    }
+  };
+
+  // 23.3.5.1 constructors:
+  bitset() {}
+  bitset(unsigned long __val) :
+    _Base_bitset<__BITSET_WORDS(_Nb,_WordT), _WordT>(__val) {}
+
+  template<class _CharT, class _Traits, class _Alloc>
+  explicit bitset(const basic_string<_CharT,_Traits,_Alloc>& __s,
+                  size_t __pos = 0,
+                  size_t __n = size_t(basic_string<_CharT,_Traits,_Alloc>::npos))
+    : _Base()
+  {
+    if (__pos > __s.size())
+      __STL_THROW(out_of_range("bitset"));
+    _M_copy_from_string(__s, __pos, __n);
+  }
+
+  // 23.3.5.2 bitset operations:
+  bitset<_Nb,_WordT>& operator&=(const bitset<_Nb,_WordT>& __rhs) {
+    _M_do_and(__rhs);
+    return *this;
+  }
+
+  bitset<_Nb,_WordT>& operator|=(const bitset<_Nb,_WordT>& __rhs) {
+    _M_do_or(__rhs);
+    return *this;
+  }
+
+  bitset<_Nb,_WordT>& operator^=(const bitset<_Nb,_WordT>& __rhs) {
+    _M_do_xor(__rhs);
+    return *this;
+  }
+
+  bitset<_Nb,_WordT>& operator<<=(size_t __pos) {
+    _M_do_left_shift(__pos);
+    _M_do_sanitize();
+    return *this;
+  }
+
+  bitset<_Nb,_WordT>& operator>>=(size_t __pos) {
+    _M_do_right_shift(__pos);
+    _M_do_sanitize();
+    return *this;
+  }
+
+  //
+  // Extension:
+  // Versions of single-bit set, reset, flip, test with no range checking.
+  //
+
+  bitset<_Nb,_WordT>& _Unchecked_set(size_t __pos) {
+    _M_getword(__pos) |= _S_maskbit(__pos);
+    return *this;
+  }
+
+  bitset<_Nb,_WordT>& _Unchecked_set(size_t __pos, int __val) {
+    if (__val)
+      _M_getword(__pos) |= _S_maskbit(__pos);
+    else
+      _M_getword(__pos) &= ~_S_maskbit(__pos);
+
+    return *this;
+  }
+
+  bitset<_Nb,_WordT>& _Unchecked_reset(size_t __pos) {
+    _M_getword(__pos) &= ~_S_maskbit(__pos);
+    return *this;
+  }
+
+  bitset<_Nb,_WordT>& _Unchecked_flip(size_t __pos) {
+    _M_getword(__pos) ^= _S_maskbit(__pos);
+    return *this;
+  }
+
+  bool _Unchecked_test(size_t __pos) const {
+    return (_M_getword(__pos) & _S_maskbit(__pos)) != static_cast<_WordT>(0);
+  }
+
+  // Set, reset, and flip.
+
+  bitset<_Nb,_WordT>& set() {
+    _M_do_set();
+    _M_do_sanitize();
+    return *this;
+  }
+
+  bitset<_Nb,_WordT>& set(size_t __pos) {
+    if (__pos >= _Nb)
+      __STL_THROW(out_of_range("bitset"));
+
+    return _Unchecked_set(__pos);
+  }
+
+  bitset<_Nb,_WordT>& set(size_t __pos, int __val) {
+    if (__pos >= _Nb)
+      __STL_THROW(out_of_range("bitset"));
+
+    return _Unchecked_set(__pos, __val);
+  }
+
+  bitset<_Nb,_WordT>& reset() {
+    _M_do_reset();
+    return *this;
+  }
+
+  bitset<_Nb,_WordT>& reset(size_t __pos) {
+    if (__pos >= _Nb)
+      __STL_THROW(out_of_range("bitset"));
+
+    return _Unchecked_reset(__pos);
+  }
+
+  bitset<_Nb,_WordT>& flip() {
+    _M_do_flip();
+    _M_do_sanitize();
+    return *this;
+  }
+
+  bitset<_Nb,_WordT>& flip(size_t __pos) {
+    if (__pos >= _Nb)
+      __STL_THROW(out_of_range("bitset"));
+
+    return _Unchecked_flip(__pos);
+  }
+
+  bitset<_Nb,_WordT> operator~() const {
+    return bitset<_Nb,_WordT>(*this).flip();
+  }
+
+  // element access:
+  //for b[i];
+  reference operator[](size_t __pos) { return reference(*this,__pos); }
+  bool operator[](size_t __pos) const { return _Unchecked_test(__pos); }
+
+  unsigned long to_ulong() const { return _M_do_to_ulong(); }
+
+#ifdef __STL_EXPLICIT_FUNCTION_TMPL_ARGS
+  template <class _CharT, class _Traits, class _Alloc>
+  basic_string<_CharT, _Traits, _Alloc> to_string() const {
+    basic_string<_CharT, _Traits, _Alloc> __result;
+    _M_copy_to_string(__result);
+    return __result;
+  }
+#endif /* __STL_EXPLICIT_FUNCTION_TMPL_ARGS */
+
+  // Helper functions for string operations.
+  template<class _CharT, class _Traits, class _Alloc>
+  void _M_copy_from_string(const basic_string<_CharT,_Traits,_Alloc>& __s,
+                          size_t,
+                          size_t);
+
+  // Helper functions for string operations.
+  template<class _CharT, class _Traits, class _Alloc>
+  void _M_copy_to_string(basic_string<_CharT,_Traits,_Alloc>&) const;
+
+  size_t count() const { return _M_do_count(); }
+
+  size_t size() const { return _Nb; }
+
+  bool operator==(const bitset<_Nb,_WordT>& __rhs) const {
+    return _M_is_equal(__rhs);
+  }
+  bool operator!=(const bitset<_Nb,_WordT>& __rhs) const {
+    return !_M_is_equal(__rhs);
+  }
+
+  bool test(size_t __pos) const {
+    if (__pos > _Nb)
+      __STL_THROW(out_of_range("bitset"));
+
+    return _Unchecked_test(__pos);
+  }
+
+  bool any() const { return _M_is_any(); }
+  bool none() const { return !_M_is_any(); }
+
+  bitset<_Nb,_WordT> operator<<(size_t __pos) const
+    { return bitset<_Nb,_WordT>(*this) <<= __pos; }
+  bitset<_Nb,_WordT> operator>>(size_t __pos) const
+    { return bitset<_Nb,_WordT>(*this) >>= __pos; }
+
+  //
+  // EXTENSIONS: bit-find operations.  These operations are
+  // experimental, and are subject to change or removal in future
+  // versions.
+  //
+
+  // find the index of the first "on" bit
+  size_t _Find_first() const
+    { return _M_do_find_first(_Nb); }
+
+  // find the index of the next "on" bit after prev
+  size_t _Find_next( size_t __prev ) const
+    { return _M_do_find_next(__prev, _Nb); }
+
+};
+
+//
+// Definitions of non-inline member functions.
+//
+
+template <size_t _Nb, class _WordT>
+template<class _CharT, class _Traits, class _Alloc>
+void bitset<_Nb, _WordT>
+  ::_M_copy_from_string(const basic_string<_CharT,_Traits,_Alloc>& __s,
+                        size_t __pos,
+                        size_t __n)
+{
+  reset();
+  const size_t __nbits = min(_Nb, min(__n, __s.size() - __pos));
+  for (size_t __i = 0; __i < __nbits; ++__i) {
+    switch(__s[__pos + __nbits - __i - 1]) {
+    case '0':
+      break;
+    case '1':
+      set(__i);
+      break;
+    default:
+      __STL_THROW(invalid_argument("bitset"));
+    }
+  }
+}
+
+template <size_t _Nb, class _WordT>
+template <class _CharT, class _Traits, class _Alloc>
+void bitset<_Nb, _WordT>
+  ::_M_copy_to_string(basic_string<_CharT, _Traits, _Alloc>& __s) const
+{
+  __s.assign(_Nb, '0');
+
+  for (size_t __i = 0; __i < _Nb; ++__i)
+    if (_Unchecked_test(__i))
+      __s[_Nb - 1 - __i] = '1';
+}
+
+// ------------------------------------------------------------
+
+//
+// 23.3.5.3 bitset operations:
+//
+
+template <size_t _Nb, class _WordT>
+inline bitset<_Nb,_WordT> operator&(const bitset<_Nb,_WordT>& __x,
+                                    const bitset<_Nb,_WordT>& __y) {
+  bitset<_Nb,_WordT> __result(__x);
+  __result &= __y;
+  return __result;
+}
+
+
+template <size_t _Nb, class _WordT>
+inline bitset<_Nb,_WordT> operator|(const bitset<_Nb,_WordT>& __x,
+                                    const bitset<_Nb,_WordT>& __y) {
+  bitset<_Nb,_WordT> __result(__x);
+  __result |= __y;
+  return __result;
+}
+
+template <size_t _Nb, class _WordT>
+inline bitset<_Nb,_WordT> operator^(const bitset<_Nb,_WordT>& __x,
+                                    const bitset<_Nb,_WordT>& __y) {
+  bitset<_Nb,_WordT> __result(__x);
+  __result ^= __y;
+  return __result;
+}
+
+// NOTE: these must be rewritten once we have templatized iostreams.
+
+template <size_t _Nb, class _WordT>
+istream&
+operator>>(istream& __is, bitset<_Nb,_WordT>& __x) {
+  string __tmp;
+  __tmp.reserve(_Nb);
+
+  // In new templatized iostreams, use istream::sentry
+  if (__is.flags() & ios::skipws) {
+    char __c;
+    do
+      __is.get(__c);
+    while (__is && isspace(__c));
+    if (__is)
+      __is.putback(__c);
+  }
+
+  for (size_t __i = 0; __i < _Nb; ++__i) {
+    char __c;
+    __is.get(__c);
+
+    if (!__is)
+      break;
+    else if (__c != '0' && __c != '1') {
+      __is.putback(__c);
+      break;
+    }
+    else
+      __tmp.push_back(__c);
+  }
+
+  if (__tmp.empty())
+    __is.clear(__is.rdstate() | ios::failbit);
+  else
+    __x._M_copy_from_string(__tmp, static_cast<size_t>(0), _Nb);
+
+  return __is;
+}
+
+template <size_t _Nb, class _WordT>
+ostream& operator<<(ostream& __os, const bitset<_Nb,_WordT>& __x) {
+  string __tmp;
+  __x._M_copy_to_string(__tmp);
+  return __os << __tmp;
+}
+
+// ------------------------------------------------------------
+// Lookup tables for find and count operations.
+
+template<bool __dummy>
+unsigned char _Bit_count<__dummy>::_S_bit_count[] = {
+  0, /*   0 */ 1, /*   1 */ 1, /*   2 */ 2, /*   3 */ 1, /*   4 */
+  2, /*   5 */ 2, /*   6 */ 3, /*   7 */ 1, /*   8 */ 2, /*   9 */
+  2, /*  10 */ 3, /*  11 */ 2, /*  12 */ 3, /*  13 */ 3, /*  14 */
+  4, /*  15 */ 1, /*  16 */ 2, /*  17 */ 2, /*  18 */ 3, /*  19 */
+  2, /*  20 */ 3, /*  21 */ 3, /*  22 */ 4, /*  23 */ 2, /*  24 */
+  3, /*  25 */ 3, /*  26 */ 4, /*  27 */ 3, /*  28 */ 4, /*  29 */
+  4, /*  30 */ 5, /*  31 */ 1, /*  32 */ 2, /*  33 */ 2, /*  34 */
+  3, /*  35 */ 2, /*  36 */ 3, /*  37 */ 3, /*  38 */ 4, /*  39 */
+  2, /*  40 */ 3, /*  41 */ 3, /*  42 */ 4, /*  43 */ 3, /*  44 */
+  4, /*  45 */ 4, /*  46 */ 5, /*  47 */ 2, /*  48 */ 3, /*  49 */
+  3, /*  50 */ 4, /*  51 */ 3, /*  52 */ 4, /*  53 */ 4, /*  54 */
+  5, /*  55 */ 3, /*  56 */ 4, /*  57 */ 4, /*  58 */ 5, /*  59 */
+  4, /*  60 */ 5, /*  61 */ 5, /*  62 */ 6, /*  63 */ 1, /*  64 */
+  2, /*  65 */ 2, /*  66 */ 3, /*  67 */ 2, /*  68 */ 3, /*  69 */
+  3, /*  70 */ 4, /*  71 */ 2, /*  72 */ 3, /*  73 */ 3, /*  74 */
+  4, /*  75 */ 3, /*  76 */ 4, /*  77 */ 4, /*  78 */ 5, /*  79 */
+  2, /*  80 */ 3, /*  81 */ 3, /*  82 */ 4, /*  83 */ 3, /*  84 */
+  4, /*  85 */ 4, /*  86 */ 5, /*  87 */ 3, /*  88 */ 4, /*  89 */
+  4, /*  90 */ 5, /*  91 */ 4, /*  92 */ 5, /*  93 */ 5, /*  94 */
+  6, /*  95 */ 2, /*  96 */ 3, /*  97 */ 3, /*  98 */ 4, /*  99 */
+  3, /* 100 */ 4, /* 101 */ 4, /* 102 */ 5, /* 103 */ 3, /* 104 */
+  4, /* 105 */ 4, /* 106 */ 5, /* 107 */ 4, /* 108 */ 5, /* 109 */
+  5, /* 110 */ 6, /* 111 */ 3, /* 112 */ 4, /* 113 */ 4, /* 114 */
+  5, /* 115 */ 4, /* 116 */ 5, /* 117 */ 5, /* 118 */ 6, /* 119 */
+  4, /* 120 */ 5, /* 121 */ 5, /* 122 */ 6, /* 123 */ 5, /* 124 */
+  6, /* 125 */ 6, /* 126 */ 7, /* 127 */ 1, /* 128 */ 2, /* 129 */
+  2, /* 130 */ 3, /* 131 */ 2, /* 132 */ 3, /* 133 */ 3, /* 134 */
+  4, /* 135 */ 2, /* 136 */ 3, /* 137 */ 3, /* 138 */ 4, /* 139 */
+  3, /* 140 */ 4, /* 141 */ 4, /* 142 */ 5, /* 143 */ 2, /* 144 */
+  3, /* 145 */ 3, /* 146 */ 4, /* 147 */ 3, /* 148 */ 4, /* 149 */
+  4, /* 150 */ 5, /* 151 */ 3, /* 152 */ 4, /* 153 */ 4, /* 154 */
+  5, /* 155 */ 4, /* 156 */ 5, /* 157 */ 5, /* 158 */ 6, /* 159 */
+  2, /* 160 */ 3, /* 161 */ 3, /* 162 */ 4, /* 163 */ 3, /* 164 */
+  4, /* 165 */ 4, /* 166 */ 5, /* 167 */ 3, /* 168 */ 4, /* 169 */
+  4, /* 170 */ 5, /* 171 */ 4, /* 172 */ 5, /* 173 */ 5, /* 174 */
+  6, /* 175 */ 3, /* 176 */ 4, /* 177 */ 4, /* 178 */ 5, /* 179 */
+  4, /* 180 */ 5, /* 181 */ 5, /* 182 */ 6, /* 183 */ 4, /* 184 */
+  5, /* 185 */ 5, /* 186 */ 6, /* 187 */ 5, /* 188 */ 6, /* 189 */
+  6, /* 190 */ 7, /* 191 */ 2, /* 192 */ 3, /* 193 */ 3, /* 194 */
+  4, /* 195 */ 3, /* 196 */ 4, /* 197 */ 4, /* 198 */ 5, /* 199 */
+  3, /* 200 */ 4, /* 201 */ 4, /* 202 */ 5, /* 203 */ 4, /* 204 */
+  5, /* 205 */ 5, /* 206 */ 6, /* 207 */ 3, /* 208 */ 4, /* 209 */
+  4, /* 210 */ 5, /* 211 */ 4, /* 212 */ 5, /* 213 */ 5, /* 214 */
+  6, /* 215 */ 4, /* 216 */ 5, /* 217 */ 5, /* 218 */ 6, /* 219 */
+  5, /* 220 */ 6, /* 221 */ 6, /* 222 */ 7, /* 223 */ 3, /* 224 */
+  4, /* 225 */ 4, /* 226 */ 5, /* 227 */ 4, /* 228 */ 5, /* 229 */
+  5, /* 230 */ 6, /* 231 */ 4, /* 232 */ 5, /* 233 */ 5, /* 234 */
+  6, /* 235 */ 5, /* 236 */ 6, /* 237 */ 6, /* 238 */ 7, /* 239 */
+  4, /* 240 */ 5, /* 241 */ 5, /* 242 */ 6, /* 243 */ 5, /* 244 */
+  6, /* 245 */ 6, /* 246 */ 7, /* 247 */ 5, /* 248 */ 6, /* 249 */
+  6, /* 250 */ 7, /* 251 */ 6, /* 252 */ 7, /* 253 */ 7, /* 254 */
+  8  /* 255 */
+}; // end _Bit_count
+
+template<bool __dummy>
+unsigned char _First_one<__dummy>::_S_first_one[] = {
+  0, /*   0 */ 0, /*   1 */ 1, /*   2 */ 0, /*   3 */ 2, /*   4 */
+  0, /*   5 */ 1, /*   6 */ 0, /*   7 */ 3, /*   8 */ 0, /*   9 */
+  1, /*  10 */ 0, /*  11 */ 2, /*  12 */ 0, /*  13 */ 1, /*  14 */
+  0, /*  15 */ 4, /*  16 */ 0, /*  17 */ 1, /*  18 */ 0, /*  19 */
+  2, /*  20 */ 0, /*  21 */ 1, /*  22 */ 0, /*  23 */ 3, /*  24 */
+  0, /*  25 */ 1, /*  26 */ 0, /*  27 */ 2, /*  28 */ 0, /*  29 */
+  1, /*  30 */ 0, /*  31 */ 5, /*  32 */ 0, /*  33 */ 1, /*  34 */
+  0, /*  35 */ 2, /*  36 */ 0, /*  37 */ 1, /*  38 */ 0, /*  39 */
+  3, /*  40 */ 0, /*  41 */ 1, /*  42 */ 0, /*  43 */ 2, /*  44 */
+  0, /*  45 */ 1, /*  46 */ 0, /*  47 */ 4, /*  48 */ 0, /*  49 */
+  1, /*  50 */ 0, /*  51 */ 2, /*  52 */ 0, /*  53 */ 1, /*  54 */
+  0, /*  55 */ 3, /*  56 */ 0, /*  57 */ 1, /*  58 */ 0, /*  59 */
+  2, /*  60 */ 0, /*  61 */ 1, /*  62 */ 0, /*  63 */ 6, /*  64 */
+  0, /*  65 */ 1, /*  66 */ 0, /*  67 */ 2, /*  68 */ 0, /*  69 */
+  1, /*  70 */ 0, /*  71 */ 3, /*  72 */ 0, /*  73 */ 1, /*  74 */
+  0, /*  75 */ 2, /*  76 */ 0, /*  77 */ 1, /*  78 */ 0, /*  79 */
+  4, /*  80 */ 0, /*  81 */ 1, /*  82 */ 0, /*  83 */ 2, /*  84 */
+  0, /*  85 */ 1, /*  86 */ 0, /*  87 */ 3, /*  88 */ 0, /*  89 */
+  1, /*  90 */ 0, /*  91 */ 2, /*  92 */ 0, /*  93 */ 1, /*  94 */
+  0, /*  95 */ 5, /*  96 */ 0, /*  97 */ 1, /*  98 */ 0, /*  99 */
+  2, /* 100 */ 0, /* 101 */ 1, /* 102 */ 0, /* 103 */ 3, /* 104 */
+  0, /* 105 */ 1, /* 106 */ 0, /* 107 */ 2, /* 108 */ 0, /* 109 */
+  1, /* 110 */ 0, /* 111 */ 4, /* 112 */ 0, /* 113 */ 1, /* 114 */
+  0, /* 115 */ 2, /* 116 */ 0, /* 117 */ 1, /* 118 */ 0, /* 119 */
+  3, /* 120 */ 0, /* 121 */ 1, /* 122 */ 0, /* 123 */ 2, /* 124 */
+  0, /* 125 */ 1, /* 126 */ 0, /* 127 */ 7, /* 128 */ 0, /* 129 */
+  1, /* 130 */ 0, /* 131 */ 2, /* 132 */ 0, /* 133 */ 1, /* 134 */
+  0, /* 135 */ 3, /* 136 */ 0, /* 137 */ 1, /* 138 */ 0, /* 139 */
+  2, /* 140 */ 0, /* 141 */ 1, /* 142 */ 0, /* 143 */ 4, /* 144 */
+  0, /* 145 */ 1, /* 146 */ 0, /* 147 */ 2, /* 148 */ 0, /* 149 */
+  1, /* 150 */ 0, /* 151 */ 3, /* 152 */ 0, /* 153 */ 1, /* 154 */
+  0, /* 155 */ 2, /* 156 */ 0, /* 157 */ 1, /* 158 */ 0, /* 159 */
+  5, /* 160 */ 0, /* 161 */ 1, /* 162 */ 0, /* 163 */ 2, /* 164 */
+  0, /* 165 */ 1, /* 166 */ 0, /* 167 */ 3, /* 168 */ 0, /* 169 */
+  1, /* 170 */ 0, /* 171 */ 2, /* 172 */ 0, /* 173 */ 1, /* 174 */
+  0, /* 175 */ 4, /* 176 */ 0, /* 177 */ 1, /* 178 */ 0, /* 179 */
+  2, /* 180 */ 0, /* 181 */ 1, /* 182 */ 0, /* 183 */ 3, /* 184 */
+  0, /* 185 */ 1, /* 186 */ 0, /* 187 */ 2, /* 188 */ 0, /* 189 */
+  1, /* 190 */ 0, /* 191 */ 6, /* 192 */ 0, /* 193 */ 1, /* 194 */
+  0, /* 195 */ 2, /* 196 */ 0, /* 197 */ 1, /* 198 */ 0, /* 199 */
+  3, /* 200 */ 0, /* 201 */ 1, /* 202 */ 0, /* 203 */ 2, /* 204 */
+  0, /* 205 */ 1, /* 206 */ 0, /* 207 */ 4, /* 208 */ 0, /* 209 */
+  1, /* 210 */ 0, /* 211 */ 2, /* 212 */ 0, /* 213 */ 1, /* 214 */
+  0, /* 215 */ 3, /* 216 */ 0, /* 217 */ 1, /* 218 */ 0, /* 219 */
+  2, /* 220 */ 0, /* 221 */ 1, /* 222 */ 0, /* 223 */ 5, /* 224 */
+  0, /* 225 */ 1, /* 226 */ 0, /* 227 */ 2, /* 228 */ 0, /* 229 */
+  1, /* 230 */ 0, /* 231 */ 3, /* 232 */ 0, /* 233 */ 1, /* 234 */
+  0, /* 235 */ 2, /* 236 */ 0, /* 237 */ 1, /* 238 */ 0, /* 239 */
+  4, /* 240 */ 0, /* 241 */ 1, /* 242 */ 0, /* 243 */ 2, /* 244 */
+  0, /* 245 */ 1, /* 246 */ 0, /* 247 */ 3, /* 248 */ 0, /* 249 */
+  1, /* 250 */ 0, /* 251 */ 2, /* 252 */ 0, /* 253 */ 1, /* 254 */
+  0, /* 255 */
+}; // end _First_one
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1209
+#endif
+
+__STL_END_NAMESPACE
+
+
+#undef __BITS_PER_WORDT
+#undef __BITSET_WORDS
+
+#endif /* __SGI_STL_BITSET */
+
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/bvector.h b/gnu/egcs/libstdc++/stl/bvector.h
new file mode 100644
index 00000000000..03a3fb1c7f2
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/bvector.h
@@ -0,0 +1,51 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_BVECTOR_H
+#define __SGI_STL_BVECTOR_H
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+#include <vector.h>
+#else
+#include <algobase.h>
+#include <alloc.h>
+#endif 
+
+#include <stl_bvector.h>
+
+#ifdef __STL_USE_NAMESPACES
+
+using __STD::bit_vector;
+
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_BVECTOR_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
+
diff --git a/gnu/egcs/libstdc++/stl/defalloc.h b/gnu/egcs/libstdc++/stl/defalloc.h
new file mode 100644
index 00000000000..0bfcc2c20a5
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/defalloc.h
@@ -0,0 +1,87 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+// Inclusion of this file is DEPRECATED.  This is the original HP
+// default allocator.  It is provided only for backward compatibility.
+// This file WILL BE REMOVED in a future release.
+//
+// DO NOT USE THIS FILE unless you have an old container implementation
+// that requires an allocator with the HP-style interface.  
+//
+// Standard-conforming allocators have a very different interface.  The
+// standard default allocator is declared in the header <memory>.
+
+#ifndef DEFALLOC_H
+#define DEFALLOC_H
+
+#include <new.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <iostream.h>
+#include <algobase.h>
+
+
+template <class T>
+inline T* allocate(ptrdiff_t size, T*) {
+    set_new_handler(0);
+    T* tmp = (T*)(::operator new((size_t)(size * sizeof(T))));
+    if (tmp == 0) {
+	cerr << "out of memory" << endl; 
+	exit(1);
+    }
+    return tmp;
+}
+
+
+template <class T>
+inline void deallocate(T* buffer) {
+    ::operator delete(buffer);
+}
+
+template <class T>
+class allocator {
+public:
+    typedef T value_type;
+    typedef T* pointer;
+    typedef const T* const_pointer;
+    typedef T& reference;
+    typedef const T& const_reference;
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    pointer allocate(size_type n) { 
+	return ::allocate((difference_type)n, (pointer)0);
+    }
+    void deallocate(pointer p) { ::deallocate(p); }
+    pointer address(reference x) { return (pointer)&x; }
+    const_pointer const_address(const_reference x) { 
+	return (const_pointer)&x; 
+    }
+    size_type init_page_size() { 
+	return max(size_type(1), size_type(4096/sizeof(T))); 
+    }
+    size_type max_size() const { 
+	return max(size_type(1), size_type(UINT_MAX/sizeof(T))); 
+    }
+};
+
+class allocator<void> {
+public:
+    typedef void* pointer;
+};
+
+
+
+#endif
diff --git a/gnu/egcs/libstdc++/stl/deque b/gnu/egcs/libstdc++/stl/deque
new file mode 100644
index 00000000000..61654acad5b
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/deque
@@ -0,0 +1,40 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_DEQUE
+#define __SGI_STL_DEQUE
+
+#include <stl_algobase.h>
+#include <stl_alloc.h>
+#include <stl_construct.h>
+#include <stl_uninitialized.h>
+#include <stl_deque.h>
+
+#endif /* __SGI_STL_DEQUE */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/deque.h b/gnu/egcs/libstdc++/stl/deque.h
new file mode 100644
index 00000000000..ede38b1ceba
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/deque.h
@@ -0,0 +1,42 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_DEQUE_H
+#define __SGI_STL_DEQUE_H
+
+#include <algobase.h>
+#include <alloc.h>
+#include <stl_deque.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::deque;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_DEQUE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/function.h b/gnu/egcs/libstdc++/stl/function.h
new file mode 100644
index 00000000000..6474dd99fa2
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/function.h
@@ -0,0 +1,118 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_FUNCTION_H
+#define __SGI_STL_FUNCTION_H
+
+#ifndef __STL_CONFIG_H
+#include <stl_config.h>
+#endif
+#ifndef __SGI_STL_INTERNAL_RELOPS
+#include <stl_relops.h>
+#endif
+#include <stddef.h>
+#ifndef __SGI_STL_INTERNAL_FUNCTION_H
+#include <stl_function.h>
+#endif
+
+#ifdef __STL_USE_NAMESPACE_FOR_RELOPS
+
+// Names from stl_relops.h
+using __STD_RELOPS::operator!=;
+using __STD_RELOPS::operator>;
+using __STD_RELOPS::operator<=;
+using __STD_RELOPS::operator>=;
+
+#endif /* __STL_USE_NAMESPACE_FOR_RELOPS */
+
+#ifdef __STL_USE_NAMESPACES
+
+// Names from stl_function.h
+using __STD::unary_function; 
+using __STD::binary_function; 
+using __STD::plus; 
+using __STD::minus; 
+using __STD::multiplies; 
+using __STD::divides; 
+using __STD::identity_element; 
+using __STD::modulus; 
+using __STD::negate; 
+using __STD::equal_to; 
+using __STD::not_equal_to; 
+using __STD::greater; 
+using __STD::less; 
+using __STD::greater_equal; 
+using __STD::less_equal; 
+using __STD::logical_and; 
+using __STD::logical_or; 
+using __STD::logical_not; 
+using __STD::unary_negate; 
+using __STD::binary_negate; 
+using __STD::not1; 
+using __STD::not2; 
+using __STD::binder1st; 
+using __STD::binder2nd; 
+using __STD::bind1st; 
+using __STD::bind2nd; 
+using __STD::unary_compose; 
+using __STD::binary_compose; 
+using __STD::compose1; 
+using __STD::compose2; 
+using __STD::pointer_to_unary_function; 
+using __STD::pointer_to_binary_function; 
+using __STD::ptr_fun; 
+using __STD::identity; 
+using __STD::select1st; 
+using __STD::select2nd; 
+using __STD::project1st; 
+using __STD::project2nd; 
+using __STD::constant_void_fun; 
+using __STD::constant_unary_fun; 
+using __STD::constant_binary_fun; 
+using __STD::constant0; 
+using __STD::constant1; 
+using __STD::constant2; 
+using __STD::subtractive_rng; 
+using __STD::mem_fun_t; 
+using __STD::const_mem_fun_t; 
+using __STD::mem_fun_ref_t; 
+using __STD::const_mem_fun_ref_t; 
+using __STD::mem_fun1_t; 
+using __STD::const_mem_fun1_t; 
+using __STD::mem_fun1_ref_t; 
+using __STD::const_mem_fun1_ref_t; 
+using __STD::mem_fun; 
+using __STD::mem_fun_ref; 
+using __STD::mem_fun1; 
+using __STD::mem_fun1_ref; 
+
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_FUNCTION_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/functional b/gnu/egcs/libstdc++/stl/functional
new file mode 100644
index 00000000000..d046dbb036d
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/functional
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef __SGI_STL_FUNCTIONAL
+#define __SGI_STL_FUNCTIONAL
+
+#include <stl_config.h>
+#include <stddef.h>
+#include <stl_function.h>
+
+#endif /* __SGI_STL_FUNCTIONAL */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/hash_map b/gnu/egcs/libstdc++/stl/hash_map
new file mode 100644
index 00000000000..f7421e026fa
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/hash_map
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef __SGI_STL_HASH_MAP
+#define __SGI_STL_HASH_MAP
+
+#ifndef __SGI_STL_INTERNAL_HASHTABLE_H
+#include <stl_hashtable.h>
+#endif 
+
+#include <stl_hash_map.h>
+
+#endif /* __SGI_STL_HASH_MAP */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/hash_map.h b/gnu/egcs/libstdc++/stl/hash_map.h
new file mode 100644
index 00000000000..f3471627044
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/hash_map.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef __SGI_STL_HASH_MAP_H
+#define __SGI_STL_HASH_MAP_H
+
+#ifndef __SGI_STL_INTERNAL_HASHTABLE_H
+#include <stl_hashtable.h>
+#endif 
+
+#include <algobase.h>
+#include <stl_hash_map.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::hash;
+using __STD::hashtable;
+using __STD::hash_map;
+using __STD::hash_multimap;
+#endif /* __STL_USE_NAMESPACES */
+
+
+#endif /* __SGI_STL_HASH_MAP_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/hash_set b/gnu/egcs/libstdc++/stl/hash_set
new file mode 100644
index 00000000000..2244f47cfa0
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/hash_set
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef __SGI_STL_HASH_SET
+#define __SGI_STL_HASH_SET
+
+#ifndef __SGI_STL_INTERNAL_HASHTABLE_H
+#include <stl_hashtable.h>
+#endif 
+
+#include <stl_hash_set.h>
+
+#endif /* __SGI_STL_HASH_SET */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/hash_set.h b/gnu/egcs/libstdc++/stl/hash_set.h
new file mode 100644
index 00000000000..d3e93c0c26b
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/hash_set.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef __SGI_STL_HASH_SET_H
+#define __SGI_STL_HASH_SET_H
+
+#ifndef __SGI_STL_INTERNAL_HASHTABLE_H
+#include <stl_hashtable.h>
+#endif 
+
+#include <algobase.h>
+#include <stl_hash_set.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::hash;
+using __STD::hashtable;
+using __STD::hash_set;
+using __STD::hash_multiset;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_HASH_SET_H */
diff --git a/gnu/egcs/libstdc++/stl/hashtable.h b/gnu/egcs/libstdc++/stl/hashtable.h
new file mode 100644
index 00000000000..15dbfc91644
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/hashtable.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_HASHTABLE_H
+#define __SGI_STL_HASHTABLE_H
+
+#include <stl_hashtable.h>
+#include <algo.h>
+#include <alloc.h>
+#include <vector.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::hash;
+using __STD::hashtable;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_HASHTABLE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/heap.h b/gnu/egcs/libstdc++/stl/heap.h
new file mode 100644
index 00000000000..2ec93c07b76
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/heap.h
@@ -0,0 +1,46 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_HEAP_H
+#define __SGI_STL_HEAP_H
+
+#include <stl_config.h>
+#include <stl_heap.h>
+
+#ifdef __STL_USE_NAMESPACES
+
+using __STD::push_heap;
+using __STD::pop_heap;
+using __STD::make_heap;
+using __STD::sort_heap;
+
+#endif /* __STL_USE_NAMESPACES */
+
+
+#endif /* __SGI_STL_HEAP_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/iterator b/gnu/egcs/libstdc++/stl/iterator
new file mode 100644
index 00000000000..4ddd208f275
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/iterator
@@ -0,0 +1,44 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_ITERATOR
+#define __SGI_STL_ITERATOR
+
+#include <stl_config.h>
+#include <stl_relops.h>
+#include <stddef.h>       /* XXX should use <cstddef> */
+#if 0                     /* XXX define a flag for this */
+#include <iostream>
+#else
+#include <iostream.h>
+#endif
+#include <stl_iterator.h>
+
+#endif /* __SGI_STL_ITERATOR */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/iterator.h b/gnu/egcs/libstdc++/stl/iterator.h
new file mode 100644
index 00000000000..f8a02377422
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/iterator.h
@@ -0,0 +1,104 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_ITERATOR_H
+#define __SGI_STL_ITERATOR_H
+
+#ifndef __SGI_STL_FUNCTION_H
+#include <function.h>
+#endif
+#include <stddef.h>
+#include <iostream.h>
+#ifndef __SGI_STL_INTERNAL_ITERATOR_H
+#include <stl_iterator.h>
+#endif
+#ifndef __TYPE_TRAITS_H
+#include <type_traits.h>
+#endif
+#ifndef __SGI_STL_INTERNAL_CONSTRUCT_H
+#include <stl_construct.h>
+#endif
+#ifndef __SGI_STL_INTERNAL_RAW_STORAGE_ITERATOR_H
+#include <stl_raw_storage_iter.h>
+#endif
+
+#ifdef __STL_USE_NAMESPACES
+
+// Names from stl_iterator.h
+
+using __STD::input_iterator_tag;
+using __STD::output_iterator_tag;
+using __STD::forward_iterator_tag;
+using __STD::bidirectional_iterator_tag;
+using __STD::random_access_iterator_tag;
+
+#if 0
+using __STD::iterator;
+#endif
+using __STD::input_iterator;
+using __STD::output_iterator;
+using __STD::forward_iterator;
+using __STD::bidirectional_iterator;
+using __STD::random_access_iterator;
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+using __STD::iterator_traits;
+#endif
+
+using __STD::iterator_category;
+using __STD::distance_type;
+using __STD::value_type;
+
+using __STD::distance; 
+using __STD::advance; 
+
+using __STD::insert_iterator;
+using __STD::front_insert_iterator;
+using __STD::back_insert_iterator;
+using __STD::inserter;
+using __STD::front_inserter;
+using __STD::back_inserter;
+
+using __STD::reverse_iterator;
+using __STD::reverse_bidirectional_iterator;
+
+using __STD::istream_iterator;
+using __STD::ostream_iterator;
+
+// Names from stl_construct.h
+using __STD::construct;
+using __STD::destroy;
+
+// Names from stl_raw_storage_iter.h
+using __STD::raw_storage_iterator;
+
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_ITERATOR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/list b/gnu/egcs/libstdc++/stl/list
new file mode 100644
index 00000000000..5294f39fea6
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/list
@@ -0,0 +1,40 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_LIST
+#define __SGI_STL_LIST
+
+#include <stl_algobase.h>
+#include <stl_alloc.h>
+#include <stl_construct.h>
+#include <stl_uninitialized.h>
+#include <stl_list.h>
+
+#endif /* __SGI_STL_LIST */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/list.h b/gnu/egcs/libstdc++/stl/list.h
new file mode 100644
index 00000000000..4e6ee0b4113
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/list.h
@@ -0,0 +1,42 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_LIST_H
+#define __SGI_STL_LIST_H
+
+#include <algobase.h>
+#include <alloc.h>
+#include <stl_list.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::list;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_LIST_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/map b/gnu/egcs/libstdc++/stl/map
new file mode 100644
index 00000000000..4cfb7652c54
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/map
@@ -0,0 +1,40 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_MAP
+#define __SGI_STL_MAP
+
+#ifndef __SGI_STL_INTERNAL_TREE_H
+#include <stl_tree.h>
+#endif
+#include <stl_map.h>
+#include <stl_multimap.h>
+
+#endif /* __SGI_STL_MAP */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/map.h b/gnu/egcs/libstdc++/stl/map.h
new file mode 100644
index 00000000000..a89bd31e81c
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/map.h
@@ -0,0 +1,41 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_MAP_H
+#define __SGI_STL_MAP_H
+
+#include <tree.h>
+#include <stl_map.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::map;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_MAP_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/memory b/gnu/egcs/libstdc++/stl/memory
new file mode 100644
index 00000000000..64338dd313a
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/memory
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef __SGI_STL_MEMORY
+#define __SGI_STL_MEMORY
+
+#include <stl_algobase.h>
+#include <stl_alloc.h>
+#include <stl_construct.h>
+#include <stl_tempbuf.h>
+#include <stl_uninitialized.h>
+#include <stl_raw_storage_iter.h>
+
+
+#if defined(__STL_MEMBER_TEMPLATES)
+
+__STL_BEGIN_NAMESPACE
+
+template <class _Tp> class auto_ptr {
+private:
+  _Tp* _M_ptr;
+
+public:
+  typedef _Tp element_type;
+  explicit auto_ptr(_Tp* __p = 0) __STL_NOTHROW : _M_ptr(__p) {}
+  auto_ptr(auto_ptr& __a) __STL_NOTHROW : _M_ptr(__a.release()) {}
+  template <class _Tp1> auto_ptr(auto_ptr<_Tp1>& __a) __STL_NOTHROW
+    : _M_ptr(__a.release()) {}
+  auto_ptr& operator=(auto_ptr& __a) __STL_NOTHROW {
+    if (&__a != this) {
+      delete _M_ptr;
+      _M_ptr = __a.release();
+    }
+    return *this;
+  }
+  template <class _Tp1>
+  auto_ptr& operator=(auto_ptr<_Tp1>& __a) __STL_NOTHROW {
+    if (__a.get() != this->get()) {
+      delete _M_ptr;
+      _M_ptr = __a.release();
+    }
+    return *this;
+  }
+  ~auto_ptr() __STL_NOTHROW { delete _M_ptr; }
+
+  _Tp& operator*() const __STL_NOTHROW {
+    return *_M_ptr;
+  }
+  _Tp* operator->() const __STL_NOTHROW {
+    return _M_ptr;
+  }
+  _Tp* get() const __STL_NOTHROW {
+    return _M_ptr;
+  }
+  _Tp* release() __STL_NOTHROW {
+    _Tp* __tmp = _M_ptr;
+    _M_ptr = 0;
+    return __tmp;
+  }
+  void reset(_Tp* __p = 0) __STL_NOTHROW {
+    delete _M_ptr;
+    _M_ptr = __p;
+  }
+
+  // According to the C++ standard, these conversions are required.  Most
+  // present-day compilers, however, do not enforce that requirement---and, 
+  // in fact, most present-day compilers do not support the language 
+  // features that these conversions rely on.
+  
+#ifdef __SGI_STL_USE_AUTO_PTR_CONVERSIONS
+
+private:
+  template<class _Tp1> struct auto_ptr_ref {
+    _Tp1* _M_ptr;
+    auto_ptr_ref(_Tp1* __p) : _M_ptr(__p) {}
+  };
+
+public:
+  auto_ptr(auto_ptr_ref<_Tp> __ref) __STL_NOTHROW
+    : _M_ptr(__ref._M_ptr) {}
+  template <class _Tp1> operator auto_ptr_ref<_Tp1>() __STL_NOTHROW 
+    { return auto_ptr_ref<_Tp>(this->release()); }
+  template <class _Tp1> operator auto_ptr<_Tp1>() __STL_NOTHROW
+    { return auto_ptr<_Tp1>(this->release()); }
+
+#endif /* __SGI_STL_USE_AUTO_PTR_CONVERSIONS */
+};
+
+__STL_END_NAMESPACE
+#endif /* member templates */
+
+#endif /* __SGI_STL_MEMORY */
+
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/multimap.h b/gnu/egcs/libstdc++/stl/multimap.h
new file mode 100644
index 00000000000..1a8ec4af4f9
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/multimap.h
@@ -0,0 +1,41 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_MULTIMAP_H
+#define __SGI_STL_MULTIMAP_H
+
+#include <tree.h>
+#include <stl_multimap.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::multimap;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_MULTIMAP_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/multiset.h b/gnu/egcs/libstdc++/stl/multiset.h
new file mode 100644
index 00000000000..3024fd74c03
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/multiset.h
@@ -0,0 +1,41 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_MULTISET_H
+#define __SGI_STL_MULTISET_H
+
+#include <tree.h>
+#include <stl_multiset.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::multiset;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_MULTISET_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/numeric b/gnu/egcs/libstdc++/stl/numeric
new file mode 100644
index 00000000000..7f048e11b56
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/numeric
@@ -0,0 +1,42 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_NUMERIC
+#define __SGI_STL_NUMERIC
+
+#include <stl_config.h>
+#include <stl_relops.h>
+#include <stddef.h>
+#include <iostream.h>
+#include <stl_iterator.h>
+#include <stl_function.h>
+#include <stl_numeric.h>
+
+#endif /* __SGI_STL_NUMERIC */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/pair.h b/gnu/egcs/libstdc++/stl/pair.h
new file mode 100644
index 00000000000..00f5caddb61
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/pair.h
@@ -0,0 +1,51 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_PAIR_H
+#define __SGI_STL_PAIR_H
+
+#ifndef __STL_CONFIG_H
+#include <stl_config.h>
+#endif
+#ifndef __SGI_STL_INTERNAL_RELOPS
+#include <stl_relops.h>
+#endif
+#ifndef __SGI_STL_INTERNAL_PAIR_H
+#include <stl_pair.h>
+#endif
+
+#ifdef __STL_USE_NAMESPACES
+
+using __STD::pair;
+using __STD::make_pair;
+
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_PAIR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/pthread_alloc b/gnu/egcs/libstdc++/stl/pthread_alloc
new file mode 100644
index 00000000000..887d8e8a154
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/pthread_alloc
@@ -0,0 +1,479 @@
+/*
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_PTHREAD_ALLOC
+#define __SGI_STL_PTHREAD_ALLOC
+
+// Pthread-specific node allocator.
+// This is similar to the default allocator, except that free-list
+// information is kept separately for each thread, avoiding locking.
+// This should be reasonably fast even in the presence of threads.
+// The down side is that storage may not be well-utilized.
+// It is not an error to allocate memory in thread A and deallocate
+// it in thread B.  But this effectively transfers ownership of the memory,
+// so that it can only be reallocated by thread B.  Thus this can effectively
+// result in a storage leak if it's done on a regular basis.
+// It can also result in frequent sharing of
+// cache lines among processors, with potentially serious performance
+// consequences.
+
+#include <stl_config.h>
+#include <stl_alloc.h>
+#ifndef __RESTRICT
+#  define __RESTRICT
+#endif
+
+__STL_BEGIN_NAMESPACE
+
+#define __STL_DATA_ALIGNMENT 8
+
+union _Pthread_alloc_obj {
+    union _Pthread_alloc_obj * __free_list_link;
+    char __client_data[__STL_DATA_ALIGNMENT];    /* The client sees this.    */
+};
+
+// Pthread allocators don't appear to the client to have meaningful
+// instances.  We do in fact need to associate some state with each
+// thread.  That state is represented by
+// _Pthread_alloc_per_thread_state<_Max_size>.
+
+template<size_t _Max_size>
+struct _Pthread_alloc_per_thread_state {
+  typedef _Pthread_alloc_obj __obj;
+  enum { _S_NFREELISTS = _Max_size/__STL_DATA_ALIGNMENT };
+  _Pthread_alloc_obj* volatile __free_list[_S_NFREELISTS]; 
+  _Pthread_alloc_per_thread_state<_Max_size> * __next; 
+	// Free list link for list of available per thread structures.
+  	// When one of these becomes available for reuse due to thread
+	// termination, any objects in its free list remain associated
+	// with it.  The whole structure may then be used by a newly
+	// created thread.
+  _Pthread_alloc_per_thread_state() : __next(0)
+  {
+    memset((void *)__free_list, 0, _S_NFREELISTS * sizeof(__obj *));
+  }
+  // Returns an object of size __n, and possibly adds to size n free list.
+  void *_M_refill(size_t __n);
+};
+
+// Pthread-specific allocator.
+// The argument specifies the largest object size allocated from per-thread
+// free lists.  Larger objects are allocated using malloc_alloc.
+// Max_size must be a power of 2.
+template <size_t _Max_size = 128>
+class _Pthread_alloc_template {
+
+public: // but only for internal use:
+
+  typedef _Pthread_alloc_obj __obj;
+
+  // Allocates a chunk for nobjs of size "size".  nobjs may be reduced
+  // if it is inconvenient to allocate the requested number.
+  static char *_S_chunk_alloc(size_t __size, int &__nobjs);
+
+  enum {_S_ALIGN = __STL_DATA_ALIGNMENT};
+
+  static size_t _S_round_up(size_t __bytes) {
+        return (((__bytes) + _S_ALIGN-1) & ~(_S_ALIGN - 1));
+  }
+  static size_t _S_freelist_index(size_t __bytes) {
+        return (((__bytes) + _S_ALIGN-1)/_S_ALIGN - 1);
+  }
+
+private:
+  // Chunk allocation state. And other shared state.
+  // Protected by _S_chunk_allocator_lock.
+  static pthread_mutex_t _S_chunk_allocator_lock;
+  static char *_S_start_free;
+  static char *_S_end_free;
+  static size_t _S_heap_size;
+  static _Pthread_alloc_per_thread_state<_Max_size>* _S_free_per_thread_states;
+  static pthread_key_t _S_key;
+  static bool _S_key_initialized;
+        // Pthread key under which per thread state is stored. 
+        // Allocator instances that are currently unclaimed by any thread.
+  static void _S_destructor(void *instance);
+        // Function to be called on thread exit to reclaim per thread
+        // state.
+  static _Pthread_alloc_per_thread_state<_Max_size> *_S_new_per_thread_state();
+        // Return a recycled or new per thread state.
+  static _Pthread_alloc_per_thread_state<_Max_size> *_S_get_per_thread_state();
+        // ensure that the current thread has an associated
+        // per thread state.
+  friend class _M_lock;
+  class _M_lock {
+      public:
+        _M_lock () { pthread_mutex_lock(&_S_chunk_allocator_lock); }
+        ~_M_lock () { pthread_mutex_unlock(&_S_chunk_allocator_lock); }
+  };
+
+public:
+
+  /* n must be > 0      */
+  static void * allocate(size_t __n)
+  {
+    __obj * volatile * __my_free_list;
+    __obj * __RESTRICT __result;
+    _Pthread_alloc_per_thread_state<_Max_size>* __a;
+
+    if (__n > _Max_size) {
+        return(malloc_alloc::allocate(__n));
+    }
+    if (!_S_key_initialized ||
+        !(__a = (_Pthread_alloc_per_thread_state<_Max_size>*)
+                                 pthread_getspecific(_S_key))) {
+        __a = _S_get_per_thread_state();
+    }
+    __my_free_list = __a -> __free_list + _S_freelist_index(__n);
+    __result = *__my_free_list;
+    if (__result == 0) {
+        void *__r = __a -> _M_refill(_S_round_up(__n));
+        return __r;
+    }
+    *__my_free_list = __result -> __free_list_link;
+    return (__result);
+  };
+
+  /* p may not be 0 */
+  static void deallocate(void *__p, size_t __n)
+  {
+    __obj *__q = (__obj *)__p;
+    __obj * volatile * __my_free_list;
+    _Pthread_alloc_per_thread_state<_Max_size>* __a;
+
+    if (__n > _Max_size) {
+        malloc_alloc::deallocate(__p, __n);
+        return;
+    }
+    if (!_S_key_initialized ||
+        !(__a = (_Pthread_alloc_per_thread_state<_Max_size> *)
+                pthread_getspecific(_S_key))) {
+        __a = _S_get_per_thread_state();
+    }
+    __my_free_list = __a->__free_list + _S_freelist_index(__n);
+    __q -> __free_list_link = *__my_free_list;
+    *__my_free_list = __q;
+  }
+
+  static void * reallocate(void *__p, size_t __old_sz, size_t __new_sz);
+
+} ;
+
+typedef _Pthread_alloc_template<> pthread_alloc;
+
+
+template <size_t _Max_size>
+void _Pthread_alloc_template<_Max_size>::_S_destructor(void * __instance)
+{
+    _M_lock __lock_instance;	// Need to acquire lock here.
+    _Pthread_alloc_per_thread_state<_Max_size>* __s =
+        (_Pthread_alloc_per_thread_state<_Max_size> *)__instance;
+    __s -> __next = _S_free_per_thread_states;
+    _S_free_per_thread_states = __s;
+}
+
+template <size_t _Max_size>
+_Pthread_alloc_per_thread_state<_Max_size> *
+_Pthread_alloc_template<_Max_size>::_S_new_per_thread_state()
+{    
+    /* lock already held here.	*/
+    if (0 != _S_free_per_thread_states) {
+        _Pthread_alloc_per_thread_state<_Max_size> *__result =
+					_S_free_per_thread_states;
+        _S_free_per_thread_states = _S_free_per_thread_states -> __next;
+        return __result;
+    } else {
+        return new _Pthread_alloc_per_thread_state<_Max_size>;
+    }
+}
+
+template <size_t _Max_size>
+_Pthread_alloc_per_thread_state<_Max_size> *
+_Pthread_alloc_template<_Max_size>::_S_get_per_thread_state()
+{
+    /*REFERENCED*/
+    _M_lock __lock_instance;	// Need to acquire lock here.
+    _Pthread_alloc_per_thread_state<_Max_size> * __result;
+    if (!_S_key_initialized) {
+        if (pthread_key_create(&_S_key, _S_destructor)) {
+            abort();  // failed
+        }
+        _S_key_initialized = true;
+    }
+    __result = _S_new_per_thread_state();
+    if (pthread_setspecific(_S_key, __result)) abort();
+    return __result;
+}
+
+/* We allocate memory in large chunks in order to avoid fragmenting     */
+/* the malloc heap too much.                                            */
+/* We assume that size is properly aligned.                             */
+template <size_t _Max_size>
+char *_Pthread_alloc_template<_Max_size>
+::_S_chunk_alloc(size_t __size, int &__nobjs)
+{
+  {
+    char * __result;
+    size_t __total_bytes;
+    size_t __bytes_left;
+    /*REFERENCED*/
+    _M_lock __lock_instance;         // Acquire lock for this routine
+
+    __total_bytes = __size * __nobjs;
+    __bytes_left = _S_end_free - _S_start_free;
+    if (__bytes_left >= __total_bytes) {
+        __result = _S_start_free;
+        _S_start_free += __total_bytes;
+        return(__result);
+    } else if (__bytes_left >= __size) {
+        __nobjs = __bytes_left/__size;
+        __total_bytes = __size * __nobjs;
+        __result = _S_start_free;
+        _S_start_free += __total_bytes;
+        return(__result);
+    } else {
+        size_t __bytes_to_get =
+		2 * __total_bytes + _S_round_up(_S_heap_size >> 4);
+        // Try to make use of the left-over piece.
+        if (__bytes_left > 0) {
+            _Pthread_alloc_per_thread_state<_Max_size>* __a = 
+                (_Pthread_alloc_per_thread_state<_Max_size>*)
+			pthread_getspecific(_S_key);
+            __obj * volatile * __my_free_list =
+                        __a->__free_list + _S_freelist_index(__bytes_left);
+
+            ((__obj *)_S_start_free) -> __free_list_link = *__my_free_list;
+            *__my_free_list = (__obj *)_S_start_free;
+        }
+#       ifdef _SGI_SOURCE
+          // Try to get memory that's aligned on something like a
+          // cache line boundary, so as to avoid parceling out
+          // parts of the same line to different threads and thus
+          // possibly different processors.
+          {
+            const int __cache_line_size = 128;  // probable upper bound
+            __bytes_to_get &= ~(__cache_line_size-1);
+            _S_start_free = (char *)memalign(__cache_line_size, __bytes_to_get); 
+            if (0 == _S_start_free) {
+              _S_start_free = (char *)malloc_alloc::allocate(__bytes_to_get);
+            }
+          }
+#       else  /* !SGI_SOURCE */
+          _S_start_free = (char *)malloc_alloc::allocate(__bytes_to_get);
+#       endif
+        _S_heap_size += __bytes_to_get;
+        _S_end_free = _S_start_free + __bytes_to_get;
+    }
+  }
+  // lock is released here
+  return(_S_chunk_alloc(__size, __nobjs));
+}
+
+
+/* Returns an object of size n, and optionally adds to size n free list.*/
+/* We assume that n is properly aligned.                                */
+/* We hold the allocation lock.                                         */
+template <size_t _Max_size>
+void *_Pthread_alloc_per_thread_state<_Max_size>
+::_M_refill(size_t __n)
+{
+    int __nobjs = 128;
+    char * __chunk =
+	_Pthread_alloc_template<_Max_size>::_S_chunk_alloc(__n, __nobjs);
+    __obj * volatile * __my_free_list;
+    __obj * __result;
+    __obj * __current_obj, * __next_obj;
+    int __i;
+
+    if (1 == __nobjs)  {
+        return(__chunk);
+    }
+    __my_free_list = __free_list
+		 + _Pthread_alloc_template<_Max_size>::_S_freelist_index(__n);
+
+    /* Build free list in chunk */
+      __result = (__obj *)__chunk;
+      *__my_free_list = __next_obj = (__obj *)(__chunk + __n);
+      for (__i = 1; ; __i++) {
+        __current_obj = __next_obj;
+        __next_obj = (__obj *)((char *)__next_obj + __n);
+        if (__nobjs - 1 == __i) {
+            __current_obj -> __free_list_link = 0;
+            break;
+        } else {
+            __current_obj -> __free_list_link = __next_obj;
+        }
+      }
+    return(__result);
+}
+
+template <size_t _Max_size>
+void *_Pthread_alloc_template<_Max_size>
+::reallocate(void *__p, size_t __old_sz, size_t __new_sz)
+{
+    void * __result;
+    size_t __copy_sz;
+
+    if (__old_sz > _Max_size
+	&& __new_sz > _Max_size) {
+        return(realloc(__p, __new_sz));
+    }
+    if (_S_round_up(__old_sz) == _S_round_up(__new_sz)) return(__p);
+    __result = allocate(__new_sz);
+    __copy_sz = __new_sz > __old_sz? __old_sz : __new_sz;
+    memcpy(__result, __p, __copy_sz);
+    deallocate(__p, __old_sz);
+    return(__result);
+}
+
+template <size_t _Max_size>
+_Pthread_alloc_per_thread_state<_Max_size> *
+_Pthread_alloc_template<_Max_size>::_S_free_per_thread_states = 0;
+
+template <size_t _Max_size>
+pthread_key_t _Pthread_alloc_template<_Max_size>::_S_key;
+
+template <size_t _Max_size>
+bool _Pthread_alloc_template<_Max_size>::_S_key_initialized = false;
+
+template <size_t _Max_size>
+pthread_mutex_t _Pthread_alloc_template<_Max_size>::_S_chunk_allocator_lock
+= PTHREAD_MUTEX_INITIALIZER;
+
+template <size_t _Max_size>
+char *_Pthread_alloc_template<_Max_size>
+::_S_start_free = 0;
+
+template <size_t _Max_size>
+char *_Pthread_alloc_template<_Max_size>
+::_S_end_free = 0;
+
+template <size_t _Max_size>
+size_t _Pthread_alloc_template<_Max_size>
+::_S_heap_size = 0;
+
+#ifdef __STL_USE_STD_ALLOCATORS
+
+template <class _Tp>
+class pthread_allocator {
+  typedef pthread_alloc _S_Alloc;          // The underlying allocator.
+public:
+  typedef size_t     size_type;
+  typedef ptrdiff_t  difference_type;
+  typedef _Tp*       pointer;
+  typedef const _Tp* const_pointer;
+  typedef _Tp&       reference;
+  typedef const _Tp& const_reference;
+  typedef _Tp        value_type;
+
+  template <class _U> struct rebind {
+    typedef pthread_allocator<_U> other;
+  };
+
+  pthread_allocator() __STL_NOTHROW {}
+  pthread_allocator(const pthread_allocator& a) __STL_NOTHROW {}
+  template <class _U> pthread_allocator(const pthread_allocator<_U>&)
+		__STL_NOTHROW {}
+  ~pthread_allocator() __STL_NOTHROW {}
+
+  pointer address(reference __x) const { return &__x; }
+  const_pointer address(const_reference __x) const { return &__x; }
+
+  // __n is permitted to be 0.  The C++ standard says nothing about what
+  // the return value is when __n == 0.
+  _Tp* allocate(size_type __n, const void* = 0) {
+    return __n != 0 ? static_cast<_Tp*>(_S_Alloc::allocate(__n * sizeof(_Tp)))
+                    : 0;
+  }
+
+  // p is not permitted to be a null pointer.
+  void deallocate(pointer __p, size_type __n)
+    { _S_Alloc::deallocate(__p, __n * sizeof(_Tp)); }
+
+  size_type max_size() const __STL_NOTHROW 
+    { return size_t(-1) / sizeof(_Tp); }
+
+  void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }
+  void destroy(pointer _p) { _p->~_Tp(); }
+};
+
+template<>
+class pthread_allocator<void> {
+public:
+  typedef size_t      size_type;
+  typedef ptrdiff_t   difference_type;
+  typedef void*       pointer;
+  typedef const void* const_pointer;
+  typedef void        value_type;
+
+  template <class _U> struct rebind {
+    typedef pthread_allocator<_U> other;
+  };
+};
+
+template <size_t _Max_size>
+inline bool operator==(const _Pthread_alloc_template<_Max_size>&,
+                       const _Pthread_alloc_template<_Max_size>&)
+{
+  return true;
+}
+
+template <class _T1, class _T2>
+inline bool operator==(const pthread_allocator<_T1>&,
+                       const pthread_allocator<_T2>& a2) 
+{
+  return true;
+}
+
+template <class _T1, class _T2>
+inline bool operator!=(const pthread_allocator<_T1>&,
+                       const pthread_allocator<_T2>&)
+{
+  return false;
+}
+
+template <class _Tp, size_t _Max_size>
+struct _Alloc_traits<_Tp, _Pthread_alloc_template<_Max_size> >
+{
+  static const bool _S_instanceless = true;
+  typedef simple_alloc<_Tp, _Pthread_alloc_template<_Max_size> > _Alloc_type;
+  typedef __allocator<_Tp, _Pthread_alloc_template<_Max_size> > 
+          allocator_type;
+};
+
+template <class _Tp, class _U, size_t _Max>
+struct _Alloc_traits<_Tp, __allocator<_U, _Pthread_alloc_template<_Max> > >
+{
+  static const bool _S_instanceless = true;
+  typedef simple_alloc<_Tp, _Pthread_alloc_template<_Max> > _Alloc_type;
+  typedef __allocator<_Tp, _Pthread_alloc_template<_Max> > allocator_type;
+};
+
+template <class _Tp, class _U>
+struct _Alloc_traits<_Tp, pthread_allocator<_U> >
+{
+  static const bool _S_instanceless = true;
+  typedef simple_alloc<_Tp, _Pthread_alloc_template<> > _Alloc_type;
+  typedef pthread_allocator<_Tp> allocator_type;
+};
+
+
+#endif /* __STL_USE_STD_ALLOCATORS */
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_PTHREAD_ALLOC */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/pthread_alloc.h b/gnu/egcs/libstdc++/stl/pthread_alloc.h
new file mode 100644
index 00000000000..774ef04edc8
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/pthread_alloc.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 1996-1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_PTHREAD_ALLOC_H
+#define __SGI_STL_PTHREAD_ALLOC_H
+
+#include <pthread_alloc>
+
+#ifdef __STL_USE_NAMESPACES
+
+using __STD::_Pthread_alloc_template;
+using __STD::pthread_alloc;
+
+#endif /* __STL_USE_NAMESPACES */
+
+
+#endif /* __SGI_STL_PTHREAD_ALLOC_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/queue b/gnu/egcs/libstdc++/stl/queue
new file mode 100644
index 00000000000..f9417fb1fbb
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/queue
@@ -0,0 +1,45 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_QUEUE
+#define __SGI_STL_QUEUE
+
+#include <stl_algobase.h>
+#include <stl_alloc.h>
+#include <stl_construct.h>
+#include <stl_uninitialized.h>
+#include <stl_vector.h>
+#include <stl_bvector.h>
+#include <stl_heap.h>
+#include <stl_deque.h>
+#include <stl_function.h>
+#include <stl_queue.h>
+
+#endif /* __SGI_STL_QUEUE */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/rope b/gnu/egcs/libstdc++/stl/rope
new file mode 100644
index 00000000000..f861500000b
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/rope
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_ROPE
+#define __SGI_STL_ROPE
+
+#include <stl_algobase.h>
+#include <stl_tempbuf.h>
+#include <stl_algo.h>
+#include <stl_function.h>
+#include <stl_numeric.h>
+#include <stl_alloc.h>
+#include <stl_construct.h>
+#include <stl_uninitialized.h>
+#include <stl_hash_fun.h>
+#include <stl_rope.h>
+
+#endif /* __SGI_STL_ROPE */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/rope.h b/gnu/egcs/libstdc++/stl/rope.h
new file mode 100644
index 00000000000..d767fa32e7a
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/rope.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_ROPE_H
+#define __SGI_STL_ROPE_H
+
+#include <hashtable.h>
+#include <stl_rope.h>
+
+#ifdef __STL_USE_NAMESPACES
+
+using __STD::char_producer; 
+using __STD::sequence_buffer; 
+using __STD::rope; 
+using __STD::crope; 
+using __STD::wrope; 
+
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_ROPE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/ropeimpl.h b/gnu/egcs/libstdc++/stl/ropeimpl.h
new file mode 100644
index 00000000000..18bb2c9ec9d
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/ropeimpl.h
@@ -0,0 +1,1550 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+# include <stdio.h>     /* XXX should use <cstdio> */
+# include <iostream.h>  /* XXX should use <iostream> */
+
+__STL_BEGIN_NAMESPACE
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1174
+#endif
+
+// Set buf_start, buf_end, and buf_ptr appropriately, filling tmp_buf
+// if necessary.  Assumes _M_path_end[leaf_index] and leaf_pos are correct.
+// Results in a valid buf_ptr if the iterator can be legitimately
+// dereferenced.
+template <class _CharT, class _Alloc>
+void _Rope_iterator_base<_CharT,_Alloc>::_S_setbuf( 
+  _Rope_iterator_base<_CharT,_Alloc>& __x)
+{
+    const _RopeRep* __leaf = __x._M_path_end[__x._M_leaf_index];
+    size_t __leaf_pos = __x._M_leaf_pos;
+    size_t __pos = __x._M_current_pos;
+
+    switch(__leaf->_M_tag) {
+	case _RopeRep::_S_leaf:
+	    __x._M_buf_start = 
+	      ((_Rope_RopeLeaf<_CharT,_Alloc>*)__leaf)->_M_data;
+	    __x._M_buf_ptr = __x._M_buf_start + (__pos - __leaf_pos);
+	    __x._M_buf_end = __x._M_buf_start + __leaf->_M_size;
+	    break;
+	case _RopeRep::_S_function:
+	case _RopeRep::_S_substringfn:
+	    {
+		size_t __len = _S_iterator_buf_len;
+		size_t __buf_start_pos = __leaf_pos;
+		size_t __leaf_end = __leaf_pos + __leaf->_M_size;
+		char_producer<_CharT>* __fn =
+			((_Rope_RopeFunction<_CharT,_Alloc>*)__leaf)->_M_fn;
+
+		if (__buf_start_pos + __len <= __pos) {
+		    __buf_start_pos = __pos - __len/4;
+		    if (__buf_start_pos + __len > __leaf_end) {
+			__buf_start_pos = __leaf_end - __len;
+		    }
+		}
+		if (__buf_start_pos + __len > __leaf_end) {
+		    __len = __leaf_end - __buf_start_pos;
+		}
+		(*__fn)(__buf_start_pos - __leaf_pos, __len, __x._M_tmp_buf);
+		__x._M_buf_ptr = __x._M_tmp_buf + (__pos - __buf_start_pos);
+		__x._M_buf_start = __x._M_tmp_buf;
+		__x._M_buf_end = __x._M_tmp_buf + __len;
+	    }
+	    break;
+	default:
+	    __stl_assert(0);
+    }
+}
+
+// Set path and buffer inside a rope iterator.  We assume that 
+// pos and root are already set.
+template <class _CharT, class _Alloc>
+void _Rope_iterator_base<_CharT,_Alloc>::_S_setcache
+(_Rope_iterator_base<_CharT,_Alloc>& __x)
+{
+    const _RopeRep* __path[_RopeRep::_S_max_rope_depth+1];
+    const _RopeRep* __curr_rope;
+    int __curr_depth = -1;  /* index into path    */
+    size_t __curr_start_pos = 0;
+    size_t __pos = __x._M_current_pos;
+    unsigned char __dirns = 0; // Bit vector marking right turns in the path
+
+    __stl_assert(__pos <= __x._M_root->_M_size);
+    if (__pos >= __x._M_root->_M_size) {
+	__x._M_buf_ptr = 0;
+	return;
+    }
+    __curr_rope = __x._M_root;
+    if (0 != __curr_rope->_M_c_string) {
+	/* Treat the root as a leaf. */
+	__x._M_buf_start = __curr_rope->_M_c_string;
+	__x._M_buf_end = __curr_rope->_M_c_string + __curr_rope->_M_size;
+	__x._M_buf_ptr = __curr_rope->_M_c_string + __pos;
+	__x._M_path_end[0] = __curr_rope;
+	__x._M_leaf_index = 0;
+	__x._M_leaf_pos = 0;
+	return;
+    }
+    for(;;) {
+	++__curr_depth;
+	__stl_assert(__curr_depth <= _RopeRep::_S_max_rope_depth);
+	__path[__curr_depth] = __curr_rope;
+	switch(__curr_rope->_M_tag) {
+	  case _RopeRep::_S_leaf:
+	  case _RopeRep::_S_function:
+	  case _RopeRep::_S_substringfn:
+	    __x._M_leaf_pos = __curr_start_pos;
+	    goto done;
+	  case _RopeRep::_S_concat:
+	    {
+		_Rope_RopeConcatenation<_CharT,_Alloc>* __c =
+			(_Rope_RopeConcatenation<_CharT,_Alloc>*)__curr_rope;
+		_RopeRep* __left = __c->_M_left;
+		size_t __left_len = __left->_M_size;
+		
+		__dirns <<= 1;
+		if (__pos >= __curr_start_pos + __left_len) {
+		    __dirns |= 1;
+		    __curr_rope = __c->_M_right;
+		    __curr_start_pos += __left_len;
+		} else {
+		    __curr_rope = __left;
+		}
+	    }
+	    break;
+	}
+    }
+  done:
+    // Copy last section of path into _M_path_end.
+      {
+	int __i = -1;
+	int __j = __curr_depth + 1 - _S_path_cache_len;
+
+	if (__j < 0) __j = 0;
+	while (__j <= __curr_depth) {
+	    __x._M_path_end[++__i] = __path[__j++];
+	}
+	__x._M_leaf_index = __i;
+      }
+      __x._M_path_directions = __dirns;
+      _S_setbuf(__x);
+}
+
+// Specialized version of the above.  Assumes that
+// the path cache is valid for the previous position.
+template <class _CharT, class _Alloc>
+void _Rope_iterator_base<_CharT,_Alloc>::_S_setcache_for_incr
+(_Rope_iterator_base<_CharT,_Alloc>& __x)
+{
+    int __current_index = __x._M_leaf_index;
+    const _RopeRep* __current_node = __x._M_path_end[__current_index];
+    size_t __len = __current_node->_M_size;
+    size_t __node_start_pos = __x._M_leaf_pos;
+    unsigned char __dirns = __x._M_path_directions;
+    _Rope_RopeConcatenation<_CharT,_Alloc>* __c;
+
+    __stl_assert(__x._M_current_pos <= __x._M_root->_M_size);
+    if (__x._M_current_pos - __node_start_pos < __len) {
+	/* More stuff in this leaf, we just didn't cache it. */
+	_S_setbuf(__x);
+	return;
+    }
+    __stl_assert(__node_start_pos + __len == __x._M_current_pos);
+    //  node_start_pos is starting position of last_node.
+    while (--__current_index >= 0) {
+	if (!(__dirns & 1) /* Path turned left */) 
+	  break;
+	__current_node = __x._M_path_end[__current_index];
+	__c = (_Rope_RopeConcatenation<_CharT,_Alloc>*)__current_node;
+	// Otherwise we were in the right child.  Thus we should pop
+	// the concatenation node.
+	__node_start_pos -= __c->_M_left->_M_size;
+	__dirns >>= 1;
+    }
+    if (__current_index < 0) {
+	// We underflowed the cache. Punt.
+	_S_setcache(__x);
+	return;
+    }
+    __current_node = __x._M_path_end[__current_index];
+    __c = (_Rope_RopeConcatenation<_CharT,_Alloc>*)__current_node;
+    // current_node is a concatenation node.  We are positioned on the first
+    // character in its right child.
+    // node_start_pos is starting position of current_node.
+    __node_start_pos += __c->_M_left->_M_size;
+    __current_node = __c->_M_right;
+    __x._M_path_end[++__current_index] = __current_node;
+    __dirns |= 1;
+    while (_RopeRep::_S_concat == __current_node->_M_tag) {
+	++__current_index;
+	if (_S_path_cache_len == __current_index) {
+	    int __i;
+	    for (__i = 0; __i < _S_path_cache_len-1; __i++) {
+		__x._M_path_end[__i] = __x._M_path_end[__i+1];
+	    }
+	    --__current_index;
+	}
+	__current_node =
+	    ((_Rope_RopeConcatenation<_CharT,_Alloc>*)__current_node)->_M_left;
+	__x._M_path_end[__current_index] = __current_node;
+	__dirns <<= 1;
+	// node_start_pos is unchanged.
+    }
+    __x._M_leaf_index = __current_index;
+    __x._M_leaf_pos = __node_start_pos;
+    __x._M_path_directions = __dirns;
+    _S_setbuf(__x);
+}
+
+template <class _CharT, class _Alloc>
+void _Rope_iterator_base<_CharT,_Alloc>::_M_incr(size_t __n) {
+    _M_current_pos += __n;
+    if (0 != _M_buf_ptr) {
+        size_t __chars_left = _M_buf_end - _M_buf_ptr;
+        if (__chars_left > __n) {
+            _M_buf_ptr += __n;
+        } else if (__chars_left == __n) {
+            _M_buf_ptr += __n;
+            _S_setcache_for_incr(*this);
+        } else {
+            _M_buf_ptr = 0;
+        }
+    }
+}
+
+template <class _CharT, class _Alloc>
+void _Rope_iterator_base<_CharT,_Alloc>::_M_decr(size_t __n) {
+    if (0 != _M_buf_ptr) {
+        size_t __chars_left = _M_buf_ptr - _M_buf_start;
+        if (__chars_left >= __n) {
+            _M_buf_ptr -= __n;
+        } else {
+            _M_buf_ptr = 0;
+        }
+    }
+    _M_current_pos -= __n;
+}
+
+template <class _CharT, class _Alloc>
+void _Rope_iterator<_CharT,_Alloc>::_M_check() {
+    if (_M_root_rope->_M_tree_ptr != _M_root) {
+        // _Rope was modified.  Get things fixed up.
+        _RopeRep::_S_unref(_M_root);
+        _M_root = _M_root_rope->_M_tree_ptr;
+        _RopeRep::_S_ref(_M_root);
+        _M_buf_ptr = 0;
+    }
+}
+
+template <class _CharT, class _Alloc>
+inline 
+_Rope_const_iterator<_CharT, _Alloc>::_Rope_const_iterator(
+  const _Rope_iterator<_CharT,_Alloc>& __x)
+: _Rope_iterator_base<_CharT,_Alloc>(__x) 
+{ }
+
+template <class _CharT, class _Alloc>
+inline _Rope_iterator<_CharT,_Alloc>::_Rope_iterator(
+  rope<_CharT,_Alloc>& __r, size_t __pos)
+: _Rope_iterator_base<_CharT,_Alloc>(__r._M_tree_ptr, __pos), 
+  _M_root_rope(&__r)
+{
+    _RopeRep::_S_ref(_M_root);
+}
+
+template <class _CharT, class _Alloc>
+inline size_t 
+rope<_CharT,_Alloc>::_S_char_ptr_len(const _CharT* __s)
+{
+    const _CharT* __p = __s;
+
+    while (!_S_is0(*__p)) { ++__p; }
+    return (__p - __s);
+}
+
+
+#ifndef __GC
+
+template <class _CharT, class _Alloc>
+inline void _Rope_RopeRep<_CharT,_Alloc>::_M_free_c_string()
+{
+    _CharT* __cstr = _M_c_string;
+    if (0 != __cstr) {
+	size_t __size = _M_size + 1;
+	destroy(__cstr, __cstr + __size);
+	_Data_deallocate(__cstr, __size);
+    }
+}
+
+
+template <class _CharT, class _Alloc>
+#ifdef __STL_USE_STD_ALLOCATORS
+  inline void _Rope_RopeRep<_CharT,_Alloc>::_S_free_string(_CharT* __s,
+							   size_t __n,
+						           allocator_type __a)
+#else
+  inline void _Rope_RopeRep<_CharT,_Alloc>::_S_free_string(_CharT* __s,
+							   size_t __n)
+#endif
+{
+    if (!_S_is_basic_char_type((_CharT*)0)) {
+	destroy(__s, __s + __n);
+    }
+//  This has to be a static member, so this gets a bit messy
+#   ifdef __STL_USE_STD_ALLOCATORS
+        __a.deallocate(
+	    __s, _Rope_RopeLeaf<_CharT,_Alloc>::_S_rounded_up_size(__n));
+#   else
+	_Data_deallocate(
+	    __s, _Rope_RopeLeaf<_CharT,_Alloc>::_S_rounded_up_size(__n));
+#   endif
+}
+
+
+//  There are several reasons for not doing this with virtual destructors
+//  and a class specific delete operator:
+//  - A class specific delete operator can't easily get access to
+//    allocator instances if we need them.
+//  - Any virtual function would need a 4 or byte vtable pointer;
+//    this only requires a one byte tag per object.
+template <class _CharT, class _Alloc>
+void _Rope_RopeRep<_CharT,_Alloc>::_M_free_tree()
+{
+    switch(_M_tag) {
+	case _S_leaf:
+	    {
+	        _Rope_RopeLeaf<_CharT,_Alloc>* __l
+			= (_Rope_RopeLeaf<_CharT,_Alloc>*)this;
+	        __l->_Rope_RopeLeaf<_CharT,_Alloc>::~_Rope_RopeLeaf();
+	        _L_deallocate(__l, 1);
+	        break;
+	    }
+	case _S_concat:
+	    {
+	        _Rope_RopeConcatenation<_CharT,_Alloc>* __c
+		    = (_Rope_RopeConcatenation<_CharT,_Alloc>*)this;
+	        __c->_Rope_RopeConcatenation<_CharT,_Alloc>::
+		       ~_Rope_RopeConcatenation();
+	        _C_deallocate(__c, 1);
+	        break;
+	    }
+	case _S_function:
+	    {
+	        _Rope_RopeFunction<_CharT,_Alloc>* __f
+		    = (_Rope_RopeFunction<_CharT,_Alloc>*)this;
+	        __f->_Rope_RopeFunction<_CharT,_Alloc>::~_Rope_RopeFunction();
+	        _F_deallocate(__f, 1);
+	        break;
+	    }
+	case _S_substringfn:
+	    {
+	        _Rope_RopeSubstring<_CharT,_Alloc>* __ss =
+			(_Rope_RopeSubstring<_CharT,_Alloc>*)this;
+		__ss->_Rope_RopeSubstring<_CharT,_Alloc>::
+		        ~_Rope_RopeSubstring();
+		_S_deallocate(__ss, 1);
+		break;
+	    }
+    }
+}
+#else
+
+template <class _CharT, class _Alloc>
+#ifdef __STL_USE_STD_ALLOCATORS
+  inline void _Rope_RopeRep<_CharT,_Alloc>::_S_free_string
+		(const _CharT*, size_t, allocator_type)
+#else
+  inline void _Rope_RopeRep<_CharT,_Alloc>::_S_free_string
+		(const _CharT*, size_t)
+#endif
+{}
+
+#endif
+
+
+// Concatenate a C string onto a leaf rope by copying the rope data.
+// Used for short ropes.
+template <class _CharT, class _Alloc>
+rope<_CharT,_Alloc>::_RopeLeaf*
+rope<_CharT,_Alloc>::_S_leaf_concat_char_iter
+		(_RopeLeaf* __r, const _CharT* __iter, size_t __len)
+{
+    size_t __old_len = __r->_M_size;
+    _CharT* __new_data = (_CharT*)
+	_Data_allocate(_S_rounded_up_size(__old_len + __len));
+    _RopeLeaf* __result;
+    
+    uninitialized_copy_n(__r->_M_data, __old_len, __new_data);
+    uninitialized_copy_n(__iter, __len, __new_data + __old_len);
+    _S_cond_store_eos(__new_data[__old_len + __len]);
+    __STL_TRY {
+	__result = _S_new_RopeLeaf(__new_data, __old_len + __len,
+				   __r->get_allocator());
+    }
+    __STL_UNWIND(_RopeRep::__STL_FREE_STRING(__new_data, __old_len + __len,
+					     __r->get_allocator()));
+    return __result;
+}
+
+#ifndef __GC
+// As above, but it's OK to clobber original if refcount is 1
+template <class _CharT, class _Alloc>
+rope<_CharT,_Alloc>::_RopeLeaf*
+rope<_CharT,_Alloc>::_S_destr_leaf_concat_char_iter
+		(_RopeLeaf* __r, const _CharT* __iter, size_t __len)
+{
+    __stl_assert(__r->_M_refcount >= 1);
+    if (__r->_M_refcount > 1)
+      return _S_leaf_concat_char_iter(__r, __iter, __len);
+    size_t __old_len = __r->_M_size;
+    if (_S_allocated_capacity(__old_len) >= __old_len + __len) {
+	// The space has been partially initialized for the standard
+	// character types.  But that doesn't matter for those types.
+	uninitialized_copy_n(__iter, __len, __r->_M_data + __old_len);
+	if (_S_is_basic_char_type((_CharT*)0)) {
+	    _S_cond_store_eos(__r->_M_data[__old_len + __len]);
+	    __stl_assert(__r->_M_c_string == __r->_M_data);
+	} else if (__r->_M_c_string != __r->_M_data && 0 != __r->_M_c_string) {
+	    __r->_M_free_c_string();
+	    __r->_M_c_string = 0;
+	}
+	__r->_M_size = __old_len + __len;
+	__stl_assert(__r->_M_refcount == 1);
+	__r->_M_refcount = 2;
+	return __r;
+    } else {
+	_RopeLeaf* __result = _S_leaf_concat_char_iter(__r, __iter, __len);
+	__stl_assert(__result->_M_refcount == 1);
+	return __result;
+    }
+}
+#endif
+
+// Assumes left and right are not 0.
+// Does not increment (nor decrement on exception) child reference counts.
+// Result has ref count 1.
+template <class _CharT, class _Alloc>
+rope<_CharT,_Alloc>::_RopeRep*
+rope<_CharT,_Alloc>::_S_tree_concat (_RopeRep* __left, _RopeRep* __right)
+{
+    _RopeConcatenation* __result =
+      _S_new_RopeConcatenation(__left, __right, __left->get_allocator());
+    size_t __depth = __result->_M_depth;
+    
+#   ifdef __STL_USE_STD_ALLOCATORS
+      __stl_assert(__left->get_allocator() == __right->get_allocator());
+#   endif
+    if (__depth > 20 && (__result->_M_size < 1000 ||
+			 __depth > _RopeRep::_S_max_rope_depth)) {
+        _RopeRep* __balanced;
+      
+	__STL_TRY {
+	   __balanced = _S_balance(__result);
+#          ifndef __GC
+	     if (__result != __balanced) {
+		__stl_assert(1 == __result->_M_refcount
+			     && 1 == __balanced->_M_refcount);
+	     }
+#          endif
+	   __result->_M_unref_nonnil();
+        }
+	__STL_UNWIND((_C_deallocate(__result,1)));
+		// In case of exception, we need to deallocate
+		// otherwise dangling result node.  But caller
+		// still owns its children.  Thus unref is
+		// inappropriate.
+	return __balanced;
+    } else {
+	return __result;
+    }
+}
+
+template <class _CharT, class _Alloc>
+rope<_CharT,_Alloc>::_RopeRep* rope<_CharT,_Alloc>::_S_concat_char_iter
+		(_RopeRep* __r, const _CharT*__s, size_t __slen)
+{
+    _RopeRep* __result;
+    if (0 == __slen) {
+	_S_ref(__r);
+	return __r;
+    }
+    if (0 == __r)
+      return __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen,
+					      __r->get_allocator());
+    if (_RopeRep::_S_leaf == __r->_M_tag && 
+          __r->_M_size + __slen <= _S_copy_max) {
+	__result = _S_leaf_concat_char_iter((_RopeLeaf*)__r, __s, __slen);
+#       ifndef __GC
+	  __stl_assert(1 == __result->_M_refcount);
+#       endif
+	return __result;
+    }
+    if (_RopeRep::_S_concat == __r->_M_tag
+	&& _RopeRep::_S_leaf == ((_RopeConcatenation*)__r)->_M_right->_M_tag) {
+	_RopeLeaf* __right = 
+	  (_RopeLeaf* )(((_RopeConcatenation* )__r)->_M_right);
+	if (__right->_M_size + __slen <= _S_copy_max) {
+	  _RopeRep* __left = ((_RopeConcatenation*)__r)->_M_left;
+	  _RopeRep* __nright = 
+	    _S_leaf_concat_char_iter((_RopeLeaf*)__right, __s, __slen);
+	  __left->_M_ref_nonnil();
+	  __STL_TRY {
+	    __result = _S_tree_concat(__left, __nright);
+          }
+	  __STL_UNWIND(_S_unref(__left); _S_unref(__nright));
+#         ifndef __GC
+	    __stl_assert(1 == __result->_M_refcount);
+#         endif
+	  return __result;
+	}
+    }
+    _RopeRep* __nright =
+      __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen, __r->get_allocator());
+    __STL_TRY {
+      __r->_M_ref_nonnil();
+      __result = _S_tree_concat(__r, __nright);
+    }
+    __STL_UNWIND(_S_unref(__r); _S_unref(__nright));
+#   ifndef __GC
+      __stl_assert(1 == __result->_M_refcount);
+#   endif
+    return __result;
+}
+
+#ifndef __GC
+template <class _CharT, class _Alloc>
+rope<_CharT,_Alloc>::_RopeRep* 
+rope<_CharT,_Alloc>::_S_destr_concat_char_iter(
+  _RopeRep* __r, const _CharT* __s, size_t __slen)
+{
+    _RopeRep* __result;
+    if (0 == __r)
+      return __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen,
+					      __r->get_allocator());
+    size_t __count = __r->_M_refcount;
+    size_t __orig_size = __r->_M_size;
+    __stl_assert(__count >= 1);
+    if (__count > 1) return _S_concat_char_iter(__r, __s, __slen);
+    if (0 == __slen) {
+	__r->_M_refcount = 2;      // One more than before
+	return __r;
+    }
+    if (__orig_size + __slen <= _S_copy_max && 
+          _RopeRep::_S_leaf == __r->_M_tag) {
+	__result = _S_destr_leaf_concat_char_iter((_RopeLeaf*)__r, __s, __slen);
+	return __result;
+    }
+    if (_RopeRep::_S_concat == __r->_M_tag) {
+	_RopeLeaf* __right = (_RopeLeaf*)(((_RopeConcatenation*)__r)->_M_right);
+	if (_RopeRep::_S_leaf == __right->_M_tag
+	    && __right->_M_size + __slen <= _S_copy_max) {
+	  _RopeRep* __new_right = 
+	    _S_destr_leaf_concat_char_iter(__right, __s, __slen);
+	  if (__right == __new_right) {
+	      __stl_assert(__new_right->_M_refcount == 2);
+	      __new_right->_M_refcount = 1;
+	  } else {
+	      __stl_assert(__new_right->_M_refcount >= 1);
+	      __right->_M_unref_nonnil();
+	  }
+	  __stl_assert(__r->_M_refcount == 1);
+	  __r->_M_refcount = 2;    // One more than before.
+	  ((_RopeConcatenation*)__r)->_M_right = __new_right;
+	  __r->_M_size = __orig_size + __slen;
+	  if (0 != __r->_M_c_string) {
+	      __r->_M_free_c_string();
+	      __r->_M_c_string = 0;
+	  }
+	  return __r;
+	}
+    }
+    _RopeRep* __right =
+      __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen, __r->get_allocator());
+    __r->_M_ref_nonnil();
+    __STL_TRY {
+      __result = _S_tree_concat(__r, __right);
+    }
+    __STL_UNWIND(_S_unref(__r); _S_unref(__right))
+    __stl_assert(1 == __result->_M_refcount);
+    return __result;
+}
+#endif /* !__GC */
+
+template <class _CharT, class _Alloc>
+rope<_CharT,_Alloc>::_RopeRep*
+rope<_CharT,_Alloc>::_S_concat(_RopeRep* __left, _RopeRep* __right)
+{
+    if (0 == __left) {
+	_S_ref(__right);
+	return __right;
+    }
+    if (0 == __right) {
+	__left->_M_ref_nonnil();
+	return __left;
+    }
+    if (_RopeRep::_S_leaf == __right->_M_tag) {
+	if (_RopeRep::_S_leaf == __left->_M_tag) {
+	  if (__right->_M_size + __left->_M_size <= _S_copy_max) {
+	    return _S_leaf_concat_char_iter((_RopeLeaf*)__left,
+					 ((_RopeLeaf*)__right)->_M_data,
+					 __right->_M_size);
+	  }
+	} else if (_RopeRep::_S_concat == __left->_M_tag
+		   && _RopeRep::_S_leaf ==
+		      ((_RopeConcatenation*)__left)->_M_right->_M_tag) {
+	  _RopeLeaf* __leftright =
+		    (_RopeLeaf*)(((_RopeConcatenation*)__left)->_M_right); 
+	  if (__leftright->_M_size + __right->_M_size <= _S_copy_max) {
+	    _RopeRep* __leftleft = ((_RopeConcatenation*)__left)->_M_left;
+	    _RopeRep* __rest = _S_leaf_concat_char_iter(__leftright,
+					   ((_RopeLeaf*)__right)->_M_data,
+					   __right->_M_size);
+	    __leftleft->_M_ref_nonnil();
+	    __STL_TRY {
+	      return(_S_tree_concat(__leftleft, __rest));
+            }
+	    __STL_UNWIND(_S_unref(__leftleft); _S_unref(__rest))
+	  }
+	}
+    }
+    __left->_M_ref_nonnil();
+    __right->_M_ref_nonnil();
+    __STL_TRY {
+      return(_S_tree_concat(__left, __right));
+    }
+    __STL_UNWIND(_S_unref(__left); _S_unref(__right));
+}
+
+template <class _CharT, class _Alloc>
+rope<_CharT,_Alloc>::_RopeRep*
+rope<_CharT,_Alloc>::_S_substring(_RopeRep* __base, 
+                               size_t __start, size_t __endp1)
+{
+    if (0 == __base) return 0;
+    size_t __len = __base->_M_size;
+    size_t __adj_endp1;
+    const size_t __lazy_threshold = 128;
+    
+    if (__endp1 >= __len) {
+	if (0 == __start) {
+	    __base->_M_ref_nonnil();
+	    return __base;
+	} else {
+	    __adj_endp1 = __len;
+	}
+    } else {
+	__adj_endp1 = __endp1;
+    }
+    switch(__base->_M_tag) {
+	case _RopeRep::_S_concat:
+	    {
+		_RopeConcatenation* __c = (_RopeConcatenation*)__base;
+		_RopeRep* __left = __c->_M_left;
+		_RopeRep* __right = __c->_M_right;
+		size_t __left_len = __left->_M_size;
+		_RopeRep* __result;
+
+		if (__adj_endp1 <= __left_len) {
+		    return _S_substring(__left, __start, __endp1);
+		} else if (__start >= __left_len) {
+		    return _S_substring(__right, __start - __left_len,
+				  __adj_endp1 - __left_len);
+		}
+		_Self_destruct_ptr __left_result(
+		  _S_substring(__left, __start, __left_len));
+		_Self_destruct_ptr __right_result(
+		  _S_substring(__right, 0, __endp1 - __left_len));
+		__result = _S_concat(__left_result, __right_result);
+#               ifndef __GC
+		  __stl_assert(1 == __result->_M_refcount);
+#               endif
+		return __result;
+	    }
+	case _RopeRep::_S_leaf:
+	    {
+		_RopeLeaf* __l = (_RopeLeaf*)__base;
+		_RopeLeaf* __result;
+		size_t __result_len;
+		if (__start >= __adj_endp1) return 0;
+		__result_len = __adj_endp1 - __start;
+		if (__result_len > __lazy_threshold) goto lazy;
+#               ifdef __GC
+		    const _CharT* __section = __l->_M_data + __start;
+		    __result = _S_new_RopeLeaf(__section, __result_len,
+					  __base->get_allocator());
+		    __result->_M_c_string = 0;  // Not eos terminated.
+#               else
+		    // We should sometimes create substring node instead.
+		    __result = __STL_ROPE_FROM_UNOWNED_CHAR_PTR(
+					__l->_M_data + __start, __result_len,
+					__base->get_allocator());
+#               endif
+		return __result;
+	    }
+	case _RopeRep::_S_substringfn:
+	    // Avoid introducing multiple layers of substring nodes.
+	    {
+		_RopeSubstring* __old = (_RopeSubstring*)__base;
+		size_t __result_len;
+		if (__start >= __adj_endp1) return 0;
+		__result_len = __adj_endp1 - __start;
+		if (__result_len > __lazy_threshold) {
+		    _RopeSubstring* __result =
+			_S_new_RopeSubstring(__old->_M_base,
+					  __start + __old->_M_start,
+					  __adj_endp1 - __start,
+					  __base->get_allocator());
+		    return __result;
+
+		} // *** else fall through: ***
+	    }
+	case _RopeRep::_S_function:
+	    {
+		_RopeFunction* __f = (_RopeFunction*)__base;
+		_CharT* __section;
+		size_t __result_len;
+		if (__start >= __adj_endp1) return 0;
+		__result_len = __adj_endp1 - __start;
+
+		if (__result_len > __lazy_threshold) goto lazy;
+		__section = (_CharT*)
+			_Data_allocate(_S_rounded_up_size(__result_len));
+		__STL_TRY {
+		  (*(__f->_M_fn))(__start, __result_len, __section);
+                }
+		__STL_UNWIND(_RopeRep::__STL_FREE_STRING(
+	               __section, __result_len, __base->get_allocator()));
+		_S_cond_store_eos(__section[__result_len]);
+		return _S_new_RopeLeaf(__section, __result_len,
+				       __base->get_allocator());
+	    }
+    }
+    /*NOTREACHED*/
+    __stl_assert(false);
+  lazy:
+    {
+	// Create substring node.
+	return _S_new_RopeSubstring(__base, __start, __adj_endp1 - __start,
+			       __base->get_allocator());
+    }
+}
+
+template<class _CharT>
+class _Rope_flatten_char_consumer : public _Rope_char_consumer<_CharT> {
+    private:
+	_CharT* _M_buf_ptr;
+    public:
+	//  _CharT* _M_buffer;  // XXX not used
+
+	_Rope_flatten_char_consumer(_CharT* __buffer) {
+	    _M_buf_ptr = __buffer;
+	};
+	~_Rope_flatten_char_consumer() {}
+	bool operator() (const _CharT* __leaf, size_t __n) {
+	    uninitialized_copy_n(__leaf, __n, _M_buf_ptr);
+	    _M_buf_ptr += __n;
+	    return true;
+	}
+};
+	    
+template<class _CharT>
+class _Rope_find_char_char_consumer : public _Rope_char_consumer<_CharT> {
+    private:
+	_CharT _M_pattern;
+    public:
+	size_t _M_count;  // Number of nonmatching characters
+	_Rope_find_char_char_consumer(_CharT __p) 
+	  : _M_pattern(__p), _M_count(0) {}
+	~_Rope_find_char_char_consumer() {}
+	bool operator() (const _CharT* __leaf, size_t __n) {
+	    size_t __i;
+	    for (__i = 0; __i < __n; __i++) {
+		if (__leaf[__i] == _M_pattern) {
+		    _M_count += __i; return false;
+		}
+	    }
+	    _M_count += __n; return true;
+	}
+};
+	    
+template<class _CharT>
+class _Rope_insert_char_consumer : public _Rope_char_consumer<_CharT> {
+    private:
+	typedef ostream _Insert_ostream;
+	_Insert_ostream& _M_o;
+    public:
+	// _CharT* buffer;    // XXX not used
+	_Rope_insert_char_consumer(_Insert_ostream& __writer) 
+	  : _M_o(__writer) {};
+	~_Rope_insert_char_consumer() { };
+		// Caller is presumed to own the ostream
+	bool operator() (const _CharT* __leaf, size_t __n);
+		// Returns true to continue traversal.
+};
+	    
+template<class _CharT>
+bool _Rope_insert_char_consumer<_CharT>::operator()
+					(const _CharT* __leaf, size_t __n)
+{
+    size_t __i;
+    //  We assume that formatting is set up correctly for each element.
+    for (__i = 0; __i < __n; __i++) _M_o << __leaf[__i];
+    return true;
+}
+
+inline bool _Rope_insert_char_consumer<char>::operator()
+					(const char* __leaf, size_t __n)
+{
+    size_t __i;
+    for (__i = 0; __i < __n; __i++) _M_o.put(__leaf[__i]);
+    return true;
+}
+
+#if 0
+// I couldn't get this to work work with the VC++ version of basic_ostream.
+// It also doesn't really do the right thing unless o is a wide stream.
+// Given that wchar_t is often 4 bytes, its not clear to me how useful
+// this stuff is anyway.
+inline bool _Rope_insert_char_consumer<wchar_t>::operator()
+					(const wchar_t* __leaf, size_t __n)
+{
+    size_t __i;
+    for (__i = 0; __i < __n; __i++) _M_o.put(__leaf[__i]);
+    return true;
+}
+#endif /* !_MSC_VER  && !BORLAND */
+
+template <class _CharT, class _Alloc>
+bool rope<_CharT, _Alloc>::_S_apply_to_pieces(
+				_Rope_char_consumer<_CharT>& __c,
+				const _RopeRep* __r,
+				size_t __begin, size_t __end)
+{
+    if (0 == __r) return true;
+    switch(__r->_M_tag) {
+	case _RopeRep::_S_concat:
+	    {
+		_RopeConcatenation* __conc = (_RopeConcatenation*)__r;
+		_RopeRep* __left =  __conc->_M_left;
+		size_t __left_len = __left->_M_size;
+		if (__begin < __left_len) {
+		    size_t __left_end = min(__left_len, __end);
+		    if (!_S_apply_to_pieces(__c, __left, __begin, __left_end))
+			return false;
+		}
+		if (__end > __left_len) {
+		    _RopeRep* __right =  __conc->_M_right;
+		    size_t __right_start = max(__left_len, __begin);
+		    if (!_S_apply_to_pieces(__c, __right,
+					 __right_start - __left_len,
+					 __end - __left_len)) {
+			return false;
+		    }
+		}
+	    }
+	    return true;
+	case _RopeRep::_S_leaf:
+	    {
+		_RopeLeaf* __l = (_RopeLeaf*)__r;
+		return __c(__l->_M_data + __begin, __end - __begin);
+	    }
+	case _RopeRep::_S_function:
+	case _RopeRep::_S_substringfn:
+	    {
+		_RopeFunction* __f = (_RopeFunction*)__r;
+		size_t __len = __end - __begin;
+		bool __result;
+		_CharT* __buffer =
+		  (_CharT*)alloc::allocate(__len * sizeof(_CharT));
+		__STL_TRY {
+		  (*(__f->_M_fn))(__begin, __end, __buffer);
+		  __result = __c(__buffer, __len);
+                  alloc::deallocate(__buffer, __len * sizeof(_CharT));
+                }
+		__STL_UNWIND((alloc::deallocate(__buffer,
+						__len * sizeof(_CharT))))
+		return __result;
+	    }
+	default:
+	    __stl_assert(false);
+	    /*NOTREACHED*/
+	    return false;
+    }
+}
+
+inline void _Rope_fill(ostream& __o, size_t __n)
+{
+    char __f = __o.fill();
+    size_t __i;
+
+    for (__i = 0; __i < __n; __i++) __o.put(__f);
+}
+    
+
+template <class _CharT> inline bool _Rope_is_simple(_CharT*) { return false; }
+inline bool _Rope_is_simple(char*) { return true; }
+inline bool _Rope_is_simple(wchar_t*) { return true; }
+
+
+template<class _CharT, class _Alloc>
+ostream& operator<< (ostream& __o, const rope<_CharT, _Alloc>& __r)
+{
+    size_t __w = __o.width();
+    bool __left = bool(__o.flags() & ios::left);
+    size_t __pad_len;
+    size_t __rope_len = __r.size();
+    _Rope_insert_char_consumer<_CharT> __c(__o);
+    bool __is_simple = _Rope_is_simple((_CharT*)0);
+    
+    if (__rope_len < __w) {
+	__pad_len = __w - __rope_len;
+    } else {
+	__pad_len = 0;
+    }
+    if (!__is_simple) __o.width(__w/__rope_len);
+    __STL_TRY {
+      if (__is_simple && !__left && __pad_len > 0) {
+	_Rope_fill(__o, __pad_len);
+      }
+      __r.apply_to_pieces(0, __r.size(), __c);
+      if (__is_simple && __left && __pad_len > 0) {
+	_Rope_fill(__o, __pad_len);
+      }
+      if (!__is_simple)
+        __o.width(__w);
+    }
+    __STL_UNWIND(if (!__is_simple) __o.width(__w))
+    return __o;
+}
+
+template <class _CharT, class _Alloc>
+_CharT*
+rope<_CharT,_Alloc>::_S_flatten(_RopeRep* __r,
+				 size_t __start, size_t __len,
+				 _CharT* __buffer)
+{
+    _Rope_flatten_char_consumer<_CharT> __c(__buffer);
+    _S_apply_to_pieces(__c, __r, __start, __start + __len);
+    return(__buffer + __len);
+}
+
+template <class _CharT, class _Alloc>
+size_t
+rope<_CharT,_Alloc>::find(_CharT __pattern, size_t __start) const
+{
+    _Rope_find_char_char_consumer<_CharT> __c(__pattern);
+    _S_apply_to_pieces(__c, _M_tree_ptr, __start, size());
+    size_type __result_pos = __start + __c._M_count;
+#   ifndef __STL_OLD_ROPE_SEMANTICS
+	if (__result_pos == size()) __result_pos = npos;
+#   endif
+    return __result_pos;
+}
+
+template <class _CharT, class _Alloc>
+_CharT*
+rope<_CharT,_Alloc>::_S_flatten(_RopeRep* __r, _CharT* __buffer)
+{
+    if (0 == __r) return __buffer;
+    switch(__r->_M_tag) {
+	case _RopeRep::_S_concat:
+	    {
+		_RopeConcatenation* __c = (_RopeConcatenation*)__r;
+		_RopeRep* __left = __c->_M_left;
+		_RopeRep* __right = __c->_M_right;
+		_CharT* __rest = _S_flatten(__left, __buffer);
+		return _S_flatten(__right, __rest);
+	    }
+	case _RopeRep::_S_leaf:
+	    {
+		_RopeLeaf* __l = (_RopeLeaf*)__r;
+		return copy_n(__l->_M_data, __l->_M_size, __buffer).second;
+	    }
+	case _RopeRep::_S_function:
+	case _RopeRep::_S_substringfn:
+	    // We dont yet do anything with substring nodes.
+	    // This needs to be fixed before ropefiles will work well.
+	    {
+		_RopeFunction* __f = (_RopeFunction*)__r;
+		(*(__f->_M_fn))(0, __f->_M_size, __buffer);
+		return __buffer + __f->_M_size;
+	    }
+	default:
+	    __stl_assert(false);
+	    /*NOTREACHED*/
+	    return 0;
+    }
+}
+
+
+// This needs work for _CharT != char
+template <class _CharT, class _Alloc>
+void
+rope<_CharT,_Alloc>::_S_dump(_RopeRep* __r, int __indent)
+{
+    for (int __i = 0; __i < __indent; __i++) putchar(' ');
+    if (0 == __r) {
+	printf("NULL\n"); return;
+    }
+    if (_RopeRep::_S_concat == __r->_M_tag) {
+	_RopeConcatenation* __c = (_RopeConcatenation*)__r;
+	_RopeRep* __left = __c->_M_left;
+	_RopeRep* __right = __c->_M_right;
+
+#       ifdef __GC
+	  printf("Concatenation %p (depth = %d, len = %ld, %s balanced)\n",
+	    __r, __r->_M_depth, __r->_M_size, __r->_M_is_balanced? "" : "not");
+#       else
+	  printf("Concatenation %p (rc = %ld, depth = %d, "
+	           "len = %ld, %s balanced)\n",
+		 __r, __r->_M_refcount, __r->_M_depth, __r->_M_size,
+		 __r->_M_is_balanced? "" : "not");
+#       endif
+	_S_dump(__left, __indent + 2);
+	_S_dump(__right, __indent + 2);
+	return;
+    } else {
+	char* __kind;
+
+	switch (__r->_M_tag) {
+	    case _RopeRep::_S_leaf:
+		__kind = "Leaf";
+		break;
+	    case _RopeRep::_S_function:
+		__kind = "Function";
+		break;
+	    case _RopeRep::_S_substringfn:
+		__kind = "Function representing substring";
+		break;
+	    default:
+		__kind = "(corrupted kind field!)";
+	}
+#       ifdef __GC
+	  printf("%s %p (depth = %d, len = %ld) ",
+		 __kind, __r, __r->_M_depth, __r->_M_size);
+#       else
+	  printf("%s %p (rc = %ld, depth = %d, len = %ld) ",
+		 __kind, __r, __r->_M_refcount, __r->_M_depth, __r->_M_size);
+#       endif
+	if (_S_is_one_byte_char_type((_CharT*)0)) {
+	    const int __max_len = 40;
+	    _Self_destruct_ptr __prefix(_S_substring(__r, 0, __max_len));
+	    _CharT __buffer[__max_len + 1];
+	    bool __too_big = __r->_M_size > __prefix->_M_size;
+
+	    _S_flatten(__prefix, __buffer);
+	    __buffer[__prefix->_M_size] = _S_eos((_CharT*)0); 
+	    printf("%s%s\n", 
+	           (char*)__buffer, __too_big? "...\n" : "\n");
+	} else {
+	    printf("\n");
+	}
+    }
+}
+
+template <class _CharT, class _Alloc>
+const unsigned long
+rope<_CharT,_Alloc>::_S_min_len[
+  _Rope_RopeRep<_CharT,_Alloc>::_S_max_rope_depth + 1] = {
+/* 0 */1, /* 1 */2, /* 2 */3, /* 3 */5, /* 4 */8, /* 5 */13, /* 6 */21,
+/* 7 */34, /* 8 */55, /* 9 */89, /* 10 */144, /* 11 */233, /* 12 */377,
+/* 13 */610, /* 14 */987, /* 15 */1597, /* 16 */2584, /* 17 */4181,
+/* 18 */6765, /* 19 */10946, /* 20 */17711, /* 21 */28657, /* 22 */46368,
+/* 23 */75025, /* 24 */121393, /* 25 */196418, /* 26 */317811,
+/* 27 */514229, /* 28 */832040, /* 29 */1346269, /* 30 */2178309,
+/* 31 */3524578, /* 32 */5702887, /* 33 */9227465, /* 34 */14930352,
+/* 35 */24157817, /* 36 */39088169, /* 37 */63245986, /* 38 */102334155,
+/* 39 */165580141, /* 40 */267914296, /* 41 */433494437,
+/* 42 */701408733, /* 43 */1134903170, /* 44 */1836311903,
+/* 45 */2971215073u };
+// These are Fibonacci numbers < 2**32.
+
+template <class _CharT, class _Alloc>
+rope<_CharT,_Alloc>::_RopeRep*
+rope<_CharT,_Alloc>::_S_balance(_RopeRep* __r)
+{
+    _RopeRep* __forest[_RopeRep::_S_max_rope_depth + 1];
+    _RopeRep* __result = 0;
+    int __i;
+    // Invariant:
+    // The concatenation of forest in descending order is equal to __r.
+    // __forest[__i]._M_size >= _S_min_len[__i]
+    // __forest[__i]._M_depth = __i
+    // References from forest are included in refcount.
+
+    for (__i = 0; __i <= _RopeRep::_S_max_rope_depth; ++__i) 
+      __forest[__i] = 0;
+    __STL_TRY {
+      _S_add_to_forest(__r, __forest);
+      for (__i = 0; __i <= _RopeRep::_S_max_rope_depth; ++__i) 
+        if (0 != __forest[__i]) {
+#	ifndef __GC
+	  _Self_destruct_ptr __old(__result);
+#	endif
+	  __result = _S_concat(__forest[__i], __result);
+	__forest[__i]->_M_unref_nonnil();
+#	if !defined(__GC) && defined(__STL_USE_EXCEPTIONS)
+	  __forest[__i] = 0;
+#	endif
+      }
+    }
+    __STL_UNWIND(for(__i = 0; __i <= _RopeRep::_S_max_rope_depth; __i++)
+		 _S_unref(__forest[__i]))
+    if (__result->_M_depth > _RopeRep::_S_max_rope_depth) abort();
+    return(__result);
+}
+
+
+template <class _CharT, class _Alloc>
+void
+rope<_CharT,_Alloc>::_S_add_to_forest(_RopeRep* __r, _RopeRep** __forest)
+{
+    if (__r->_M_is_balanced) {
+	_S_add_leaf_to_forest(__r, __forest);
+	return;
+    }
+    __stl_assert(__r->_M_tag == _RopeRep::_S_concat);
+    {
+	_RopeConcatenation* __c = (_RopeConcatenation*)__r;
+
+	_S_add_to_forest(__c->_M_left, __forest);
+	_S_add_to_forest(__c->_M_right, __forest);
+    }
+}
+
+
+template <class _CharT, class _Alloc>
+void
+rope<_CharT,_Alloc>::_S_add_leaf_to_forest(_RopeRep* __r, _RopeRep** __forest)
+{
+    _RopeRep* __insertee;   		// included in refcount
+    _RopeRep* __too_tiny = 0;    	// included in refcount
+    int __i;  				// forest[0..__i-1] is empty
+    size_t __s = __r->_M_size;
+
+    for (__i = 0; __s >= _S_min_len[__i+1]/* not this bucket */; ++__i) {
+	if (0 != __forest[__i]) {
+#	    ifndef __GC
+	      _Self_destruct_ptr __old(__too_tiny);
+#	    endif
+	    __too_tiny = _S_concat_and_set_balanced(__forest[__i], __too_tiny);
+	    __forest[__i]->_M_unref_nonnil();
+	    __forest[__i] = 0;
+	}
+    }
+    {
+#	ifndef __GC
+	  _Self_destruct_ptr __old(__too_tiny);
+#	endif
+	__insertee = _S_concat_and_set_balanced(__too_tiny, __r);
+    }
+    // Too_tiny dead, and no longer included in refcount.
+    // Insertee is live and included.
+    __stl_assert(_S_is_almost_balanced(__insertee));
+    __stl_assert(__insertee->_M_depth <= __r->_M_depth + 1);
+    for (;; ++__i) {
+	if (0 != __forest[__i]) {
+#	    ifndef __GC
+	      _Self_destruct_ptr __old(__insertee);
+#	    endif
+	    __insertee = _S_concat_and_set_balanced(__forest[__i], __insertee);
+	    __forest[__i]->_M_unref_nonnil();
+	    __forest[__i] = 0;
+	    __stl_assert(_S_is_almost_balanced(__insertee));
+	}
+	__stl_assert(_S_min_len[__i] <= __insertee->_M_size);
+	__stl_assert(__forest[__i] == 0);
+	if (__i == _RopeRep::_S_max_rope_depth || 
+	      __insertee->_M_size < _S_min_len[__i+1]) {
+	    __forest[__i] = __insertee;
+	    // refcount is OK since __insertee is now dead.
+	    return;
+	}
+    }
+}
+
+template <class _CharT, class _Alloc>
+_CharT
+rope<_CharT,_Alloc>::_S_fetch(_RopeRep* __r, size_type __i)
+{
+    __GC_CONST _CharT* __cstr = __r->_M_c_string;
+
+    __stl_assert(__i < __r->_M_size);
+    if (0 != __cstr) return __cstr[__i]; 
+    for(;;) {
+      switch(__r->_M_tag) {
+	case _RopeRep::_S_concat:
+	    {
+		_RopeConcatenation* __c = (_RopeConcatenation*)__r;
+		_RopeRep* __left = __c->_M_left;
+		size_t __left_len = __left->_M_size;
+
+		if (__i >= __left_len) {
+		    __i -= __left_len;
+		    __r = __c->_M_right;
+		} else {
+		    __r = __left;
+		}
+	    }
+	    break;
+	case _RopeRep::_S_leaf:
+	    {
+		_RopeLeaf* __l = (_RopeLeaf*)__r;
+		return __l->_M_data[__i];
+	    }
+	case _RopeRep::_S_function:
+	case _RopeRep::_S_substringfn:
+	    {
+		_RopeFunction* __f = (_RopeFunction*)__r;
+		_CharT __result;
+
+		(*(__f->_M_fn))(__i, 1, &__result);
+		return __result;
+	    }
+      }
+    }
+}
+
+# ifndef __GC
+// Return a uniquely referenced character slot for the given
+// position, or 0 if that's not possible.
+template <class _CharT, class _Alloc>
+_CharT*
+rope<_CharT,_Alloc>::_S_fetch_ptr(_RopeRep* __r, size_type __i)
+{
+    _RopeRep* __clrstack[_RopeRep::_S_max_rope_depth];
+    size_t __csptr = 0;
+
+    for(;;) {
+      if (__r->_M_refcount > 1) return 0;
+      switch(__r->_M_tag) {
+	case _RopeRep::_S_concat:
+	    {
+		_RopeConcatenation* __c = (_RopeConcatenation*)__r;
+		_RopeRep* __left = __c->_M_left;
+		size_t __left_len = __left->_M_size;
+
+		if (__c->_M_c_string != 0) __clrstack[__csptr++] = __c;
+		if (__i >= __left_len) {
+		    __i -= __left_len;
+		    __r = __c->_M_right;
+		} else {
+		    __r = __left;
+		}
+	    }
+	    break;
+	case _RopeRep::_S_leaf:
+	    {
+		_RopeLeaf* __l = (_RopeLeaf*)__r;
+		if (__l->_M_c_string != __l->_M_data && __l->_M_c_string != 0)
+		    __clrstack[__csptr++] = __l;
+		while (__csptr > 0) {
+		    -- __csptr;
+		    _RopeRep* __d = __clrstack[__csptr];
+		    __d->_M_free_c_string();
+		    __d->_M_c_string = 0;
+		}
+		return __l->_M_data + __i;
+	    }
+	case _RopeRep::_S_function:
+	case _RopeRep::_S_substringfn:
+	    return 0;
+      }
+    }
+}
+# endif /* __GC */
+
+// The following could be implemented trivially using
+// lexicographical_compare_3way.
+// We do a little more work to avoid dealing with rope iterators for
+// flat strings.
+template <class _CharT, class _Alloc>
+int
+rope<_CharT,_Alloc>::_S_compare (const _RopeRep* __left, 
+                                 const _RopeRep* __right)
+{
+    size_t __left_len;
+    size_t __right_len;
+
+    if (0 == __right) return 0 != __left;
+    if (0 == __left) return -1;
+    __left_len = __left->_M_size;
+    __right_len = __right->_M_size;
+    if (_RopeRep::_S_leaf == __left->_M_tag) {
+	_RopeLeaf* __l = (_RopeLeaf*) __left;
+	if (_RopeRep::_S_leaf == __right->_M_tag) {
+	    _RopeLeaf* __r = (_RopeLeaf*) __right;
+	    return lexicographical_compare_3way(
+			__l->_M_data, __l->_M_data + __left_len,
+			__r->_M_data, __r->_M_data + __right_len);
+	} else {
+	    const_iterator __rstart(__right, 0);
+	    const_iterator __rend(__right, __right_len);
+	    return lexicographical_compare_3way(
+			__l->_M_data, __l->_M_data + __left_len,
+			__rstart, __rend);
+	}
+    } else {
+	const_iterator __lstart(__left, 0);
+	const_iterator __lend(__left, __left_len);
+	if (_RopeRep::_S_leaf == __right->_M_tag) {
+	    _RopeLeaf* __r = (_RopeLeaf*) __right;
+	    return lexicographical_compare_3way(
+				   __lstart, __lend,
+				   __r->_M_data, __r->_M_data + __right_len);
+	} else {
+	    const_iterator __rstart(__right, 0);
+	    const_iterator __rend(__right, __right_len);
+	    return lexicographical_compare_3way(
+				   __lstart, __lend,
+				   __rstart, __rend);
+	}
+    }
+}
+
+// Assignment to reference proxies.
+template <class _CharT, class _Alloc>
+_Rope_char_ref_proxy<_CharT, _Alloc>&
+_Rope_char_ref_proxy<_CharT, _Alloc>::operator= (_CharT __c) {
+    _RopeRep* __old = _M_root->_M_tree_ptr;
+#   ifndef __GC
+	// First check for the case in which everything is uniquely
+	// referenced.  In that case we can do this destructively.
+	_CharT* __ptr = _My_rope::_S_fetch_ptr(__old, _M_pos);
+	if (0 != __ptr) {
+	    *__ptr = __c;
+	    return *this;
+	}
+#   endif
+    _Self_destruct_ptr __left(
+      _My_rope::_S_substring(__old, 0, _M_pos));
+    _Self_destruct_ptr __right(
+      _My_rope::_S_substring(__old, _M_pos+1, __old->_M_size));
+    _Self_destruct_ptr __result_left(
+      _My_rope::_S_destr_concat_char_iter(__left, &__c, 1));
+
+#   ifndef __GC
+      __stl_assert(__left == __result_left || 1 == __result_left->_M_refcount);
+#   endif
+    _RopeRep* __result =
+		_My_rope::_S_concat(__result_left, __right);
+#   ifndef __GC
+      __stl_assert(1 <= __result->_M_refcount);
+      _RopeRep::_S_unref(__old);
+#   endif
+    _M_root->_M_tree_ptr = __result;
+    return *this;
+}
+
+template <class _CharT, class _Alloc>
+inline _Rope_char_ref_proxy<_CharT, _Alloc>::operator _CharT () const
+{
+    if (_M_current_valid) {
+	return _M_current;
+    } else {
+        return _My_rope::_S_fetch(_M_root->_M_tree_ptr, _M_pos);
+    }
+}
+template <class _CharT, class _Alloc>
+_Rope_char_ptr_proxy<_CharT, _Alloc>
+_Rope_char_ref_proxy<_CharT, _Alloc>::operator& () const {
+    return _Rope_char_ptr_proxy<_CharT, _Alloc>(*this);
+}
+
+template <class _CharT, class _Alloc>
+rope<_CharT, _Alloc>::rope(size_t __n, _CharT __c,
+			   const allocator_type& __a)
+: _Base(__a)
+{
+    rope<_CharT,_Alloc> __result;
+    const size_t __exponentiate_threshold = 32;
+    size_t __exponent;
+    size_t __rest;
+    _CharT* __rest_buffer;
+    _RopeRep* __remainder;
+    rope<_CharT,_Alloc> __remainder_rope;
+
+    if (0 == __n)
+      return;
+    
+    __exponent = __n / __exponentiate_threshold;
+    __rest = __n % __exponentiate_threshold;
+    if (0 == __rest) {
+	__remainder = 0;
+    } else {
+	__rest_buffer = _Data_allocate(_S_rounded_up_size(__rest));
+	uninitialized_fill_n(__rest_buffer, __rest, __c);
+	_S_cond_store_eos(__rest_buffer[__rest]);
+	__STL_TRY {
+	    __remainder = _S_new_RopeLeaf(__rest_buffer, __rest, __a);
+        }
+	__STL_UNWIND(_RopeRep::__STL_FREE_STRING(__rest_buffer, __rest, __a))
+    }
+    __remainder_rope._M_tree_ptr = __remainder;
+    if (__exponent != 0) {
+	_CharT* __base_buffer =
+	  _Data_allocate(_S_rounded_up_size(__exponentiate_threshold));
+	_RopeLeaf* __base_leaf;
+	rope __base_rope;
+	uninitialized_fill_n(__base_buffer, __exponentiate_threshold, __c);
+	_S_cond_store_eos(__base_buffer[__exponentiate_threshold]);
+	__STL_TRY {
+          __base_leaf = _S_new_RopeLeaf(__base_buffer,
+                                        __exponentiate_threshold, __a);
+        }
+	__STL_UNWIND(_RopeRep::__STL_FREE_STRING(__base_buffer, 
+	                                         __exponentiate_threshold, __a))
+	__base_rope._M_tree_ptr = __base_leaf;
+ 	if (1 == __exponent) {
+	  __result = __base_rope;
+#         ifndef __GC
+	    __stl_assert(2 == __result._M_tree_ptr->_M_refcount);
+		// One each for base_rope and __result
+#         endif
+	} else {
+	  // XXX what is power()?
+	  __result = power(__base_rope, __exponent, _Concat_fn());
+	}
+	if (0 != __remainder) {
+	  __result += __remainder_rope;
+	}
+    } else {
+	__result = __remainder_rope;
+    }
+    _M_tree_ptr = __result._M_tree_ptr;
+    _M_tree_ptr->_M_ref_nonnil();
+}
+
+template<class _CharT, class _Alloc>
+  _CharT rope<_CharT,_Alloc>::_S_empty_c_str[1];
+
+# ifdef __STL_PTHREADS
+    template<class _CharT, class _Alloc>
+    pthread_mutex_t 
+    rope<_CharT,_Alloc>::_S_swap_lock = PTHREAD_MUTEX_INITIALIZER;
+# endif
+
+template<class _CharT, class _Alloc>
+const _CharT* rope<_CharT,_Alloc>::c_str() const {
+    if (0 == _M_tree_ptr) {
+        _S_empty_c_str[0] = _S_eos((_CharT*)0);  // Possibly redundant,
+					     // but probably fast.
+        return _S_empty_c_str;
+    }
+    __GC_CONST _CharT* __old_c_string = _M_tree_ptr->_M_c_string;
+    if (0 != __old_c_string) return(__old_c_string);
+    size_t __s = size();
+    _CharT* __result = _Data_allocate(__s + 1);
+    _S_flatten(_M_tree_ptr, __result);
+    __result[__s] = _S_eos((_CharT*)0);
+#   ifdef __GC
+	_M_tree_ptr->_M_c_string = __result;
+#   else
+      if ((__old_c_string = 
+             _S_atomic_swap(&(_M_tree_ptr->_M_c_string), __result)) != 0) {
+	// It must have been added in the interim.  Hence it had to have been
+	// separately allocated.  Deallocate the old copy, since we just
+	// replaced it.
+	destroy(__old_c_string, __old_c_string + __s + 1);
+	_Data_deallocate(__old_c_string, __s + 1);
+      }
+#   endif
+    return(__result);
+}
+
+template<class _CharT, class _Alloc>
+const _CharT* rope<_CharT,_Alloc>::replace_with_c_str() {
+    if (0 == _M_tree_ptr) {
+        _S_empty_c_str[0] = _S_eos((_CharT*)0);
+        return _S_empty_c_str;
+    }
+    __GC_CONST _CharT* __old_c_string = _M_tree_ptr->_M_c_string;
+    if (_RopeRep::_S_leaf == _M_tree_ptr->_M_tag && 0 != __old_c_string) {
+	return(__old_c_string);
+    }
+    size_t __s = size();
+    _CharT* __result = _Data_allocate(_S_rounded_up_size(__s));
+    _S_flatten(_M_tree_ptr, __result);
+    __result[__s] = _S_eos((_CharT*)0);
+    _M_tree_ptr->_M_unref_nonnil();
+    _M_tree_ptr = _S_new_RopeLeaf(__result, __s, get_allocator());
+    return(__result);
+}
+
+// Algorithm specializations.  More should be added.
+
+#ifndef _MSC_VER
+// I couldn't get this to work with VC++
+template<class _CharT,class _Alloc>
+void
+_Rope_rotate(_Rope_iterator<_CharT,_Alloc> __first,
+              _Rope_iterator<_CharT,_Alloc> __middle,
+              _Rope_iterator<_CharT,_Alloc> __last)
+{
+    __stl_assert(__first.container() == __middle.container()
+                 && __middle.container() == __last.container());
+    rope<_CharT,_Alloc>& __r(__first.container());
+    rope<_CharT,_Alloc> __prefix = __r.substr(0, __first.index());
+    rope<_CharT,_Alloc> __suffix = 
+      __r.substr(__last.index(), __r.size() - __last.index());
+    rope<_CharT,_Alloc> __part1 = 
+      __r.substr(__middle.index(), __last.index() - __middle.index());
+    rope<_CharT,_Alloc> __part2 = 
+      __r.substr(__first.index(), __middle.index() - __first.index());
+    __r = __prefix;
+    __r += __part1;
+    __r += __part2;
+    __r += __suffix;
+}
+
+#if !defined(__GNUC__)
+// Appears to confuse g++
+inline void rotate(_Rope_iterator<char,__STL_DEFAULT_ALLOCATOR(char)> __first,
+                   _Rope_iterator<char,__STL_DEFAULT_ALLOCATOR(char)> __middle,
+                   _Rope_iterator<char,__STL_DEFAULT_ALLOCATOR(char)> __last) {
+    _Rope_rotate(__first, __middle, __last);
+}
+#endif
+
+# if 0
+// Probably not useful for several reasons:
+// - for SGIs 7.1 compiler and probably some others,
+//   this forces lots of rope<wchar_t, ...> instantiations, creating a
+//   code bloat and compile time problem.  (Fixed in 7.2.)
+// - wchar_t is 4 bytes wide on most UNIX platforms, making it unattractive
+//   for unicode strings.  Unsigned short may be a better character
+//   type.
+inline void rotate(
+		_Rope_iterator<wchar_t,__STL_DEFAULT_ALLOCATOR(char)> __first,
+                _Rope_iterator<wchar_t,__STL_DEFAULT_ALLOCATOR(char)> __middle,
+                _Rope_iterator<wchar_t,__STL_DEFAULT_ALLOCATOR(char)> __last) {
+    _Rope_rotate(__first, __middle, __last);
+}
+# endif
+#endif /* _MSC_VER */
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1174
+#endif
+
+__STL_END_NAMESPACE
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/set b/gnu/egcs/libstdc++/stl/set
new file mode 100644
index 00000000000..c836c4596d2
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/set
@@ -0,0 +1,40 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_SET
+#define __SGI_STL_SET
+
+#ifndef __SGI_STL_INTERNAL_TREE_H
+#include <stl_tree.h>
+#endif
+#include <stl_set.h>
+#include <stl_multiset.h>
+
+#endif /* __SGI_STL_SET */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/set.h b/gnu/egcs/libstdc++/stl/set.h
new file mode 100644
index 00000000000..9004d2e0477
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/set.h
@@ -0,0 +1,41 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_SET_H
+#define __SGI_STL_SET_H
+
+#include <tree.h>
+#include <stl_set.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::set;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_SET_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/slist b/gnu/egcs/libstdc++/stl/slist
new file mode 100644
index 00000000000..c3ec74204c5
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/slist
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef __SGI_STL_SLIST
+#define __SGI_STL_SLIST
+
+#include <stl_algobase.h>
+#include <stl_alloc.h>
+#include <stl_construct.h>
+#include <stl_uninitialized.h>
+#include <stl_slist.h>
+
+#endif /* __SGI_STL_SLIST */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/slist.h b/gnu/egcs/libstdc++/stl/slist.h
new file mode 100644
index 00000000000..d2377b0cf5a
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/slist.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef __SGI_STL_SLIST_H
+#define __SGI_STL_SLIST_H
+
+#include <algobase.h>
+#include <alloc.h>
+#include <stl_slist.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::slist;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_SLIST_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stack b/gnu/egcs/libstdc++/stl/stack
new file mode 100644
index 00000000000..36461d95b8c
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stack
@@ -0,0 +1,41 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_STACK
+#define __SGI_STL_STACK
+
+#include <stl_algobase.h>
+#include <stl_alloc.h>
+#include <stl_construct.h>
+#include <stl_uninitialized.h>
+#include <stl_deque.h>
+#include <stl_stack.h>
+
+#endif /* __SGI_STL_STACK */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stack.h b/gnu/egcs/libstdc++/stl/stack.h
new file mode 100644
index 00000000000..89beca82f12
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stack.h
@@ -0,0 +1,46 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_STACK_H
+#define __SGI_STL_STACK_H
+
+#include <vector.h>
+#include <deque.h>
+#include <heap.h>
+#include <stl_stack.h>
+#include <stl_queue.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::stack;
+using __STD::queue;
+using __STD::priority_queue;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_STACK_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_algo.h b/gnu/egcs/libstdc++/stl/stl_algo.h
new file mode 100644
index 00000000000..57607ba5d49
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_algo.h
@@ -0,0 +1,2894 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_ALGO_H
+#define __SGI_STL_INTERNAL_ALGO_H
+
+#include <stl_heap.h>
+
+__STL_BEGIN_NAMESPACE
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1209
+#endif
+
+// __median (an extension, not present in the C++ standard).
+
+template <class _Tp>
+inline const _Tp& __median(const _Tp& __a, const _Tp& __b, const _Tp& __c) {
+  if (__a < __b)
+    if (__b < __c)
+      return __b;
+    else if (__a < __c)
+      return __c;
+    else
+      return __a;
+  else if (__a < __c)
+    return __a;
+  else if (__b < __c)
+    return __c;
+  else
+    return __b;
+}
+
+template <class _Tp, class _Compare>
+inline const _Tp&
+__median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp) {
+  if (__comp(__a, __b))
+    if (__comp(__b, __c))
+      return __b;
+    else if (__comp(__a, __c))
+      return __c;
+    else
+      return __a;
+  else if (__comp(__a, __c))
+    return __a;
+  else if (__comp(__b, __c))
+    return __c;
+  else
+    return __b;
+}
+
+// for_each.  Apply a function to every element of a range.
+template <class _InputIter, class _Function>
+_Function for_each(_InputIter __first, _InputIter __last, _Function __f) {
+  for ( ; __first != __last; ++__first)
+    __f(*__first);
+  return __f;
+}
+
+// find and find_if.
+
+template <class _InputIter, class _Tp>
+inline _InputIter find(_InputIter __first, _InputIter __last,
+                       const _Tp& __val,
+                       input_iterator_tag)
+{
+  while (__first != __last && *__first != __val)
+    ++__first;
+  return __first;
+}
+
+template <class _InputIter, class _Predicate>
+inline _InputIter find_if(_InputIter __first, _InputIter __last,
+                          _Predicate __pred,
+                          input_iterator_tag)
+{
+  while (__first != __last && !__pred(*__first))
+    ++__first;
+  return __first;
+}
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class _RandomAccessIter, class _Tp>
+_RandomAccessIter find(_RandomAccessIter __first, _RandomAccessIter __last,
+                       const _Tp& __val,
+                       random_access_iterator_tag)
+{
+  typename iterator_traits<_RandomAccessIter>::difference_type __trip_count
+    = (__last - __first) >> 2;
+
+  for ( ; __trip_count > 0 ; --__trip_count) {
+    if (*__first == __val) return __first;
+    ++__first;
+
+    if (*__first == __val) return __first;
+    ++__first;
+
+    if (*__first == __val) return __first;
+    ++__first;
+
+    if (*__first == __val) return __first;
+    ++__first;
+  }
+
+  switch(__last - __first) {
+  case 3:
+    if (*__first == __val) return __first;
+    ++__first;
+  case 2:
+    if (*__first == __val) return __first;
+    ++__first;
+  case 1:
+    if (*__first == __val) return __first;
+    ++__first;
+  case 0:
+  default:
+    return __last;
+  }
+}
+
+template <class _RandomAccessIter, class _Predicate>
+_RandomAccessIter find_if(_RandomAccessIter __first, _RandomAccessIter __last,
+                          _Predicate __pred,
+                          random_access_iterator_tag)
+{
+  typename iterator_traits<_RandomAccessIter>::difference_type __trip_count
+    = (__last - __first) >> 2;
+
+  for ( ; __trip_count > 0 ; --__trip_count) {
+    if (__pred(*__first)) return __first;
+    ++__first;
+
+    if (__pred(*__first)) return __first;
+    ++__first;
+
+    if (__pred(*__first)) return __first;
+    ++__first;
+
+    if (__pred(*__first)) return __first;
+    ++__first;
+  }
+
+  switch(__last - __first) {
+  case 3:
+    if (__pred(*__first)) return __first;
+    ++__first;
+  case 2:
+    if (__pred(*__first)) return __first;
+    ++__first;
+  case 1:
+    if (__pred(*__first)) return __first;
+    ++__first;
+  case 0:
+  default:
+    return __last;
+  }
+}
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+template <class _InputIter, class _Tp>
+inline _InputIter find(_InputIter __first, _InputIter __last,
+                       const _Tp& __val)
+{
+  return find(__first, __last, __val, __ITERATOR_CATEGORY(__first));
+}
+
+template <class _InputIter, class _Predicate>
+inline _InputIter find_if(_InputIter __first, _InputIter __last,
+                          _Predicate __pred) {
+  return find_if(__first, __last, __pred, __ITERATOR_CATEGORY(__first));
+}
+
+// adjacent_find.
+
+template <class _ForwardIter>
+_ForwardIter adjacent_find(_ForwardIter __first, _ForwardIter __last) {
+  if (__first == __last)
+    return __last;
+  _ForwardIter __next = __first;
+  while(++__next != __last) {
+    if (*__first == *__next)
+      return __first;
+    __first = __next;
+  }
+  return __last;
+}
+
+template <class _ForwardIter, class _BinaryPredicate>
+_ForwardIter adjacent_find(_ForwardIter __first, _ForwardIter __last,
+                           _BinaryPredicate __binary_pred) {
+  if (__first == __last)
+    return __last;
+  _ForwardIter __next = __first;
+  while(++__next != __last) {
+    if (__binary_pred(*__first, *__next))
+      return __first;
+    __first = __next;
+  }
+  return __last;
+}
+
+// count and count_if.  There are two version of each, one whose return type
+// type is void and one (present only if we have partial specialization)
+// whose return type is iterator_traits<_InputIter>::difference_type.  The
+// C++ standard only has the latter version, but the former, which was present
+// in the HP STL, is retained for backward compatibility.
+
+template <class _InputIter, class _Tp, class _Size>
+void count(_InputIter __first, _InputIter __last, const _Tp& __value,
+           _Size& __n) {
+  for ( ; __first != __last; ++__first)
+    if (*__first == __value)
+      ++__n;
+}
+
+template <class _InputIter, class _Predicate, class _Size>
+void count_if(_InputIter __first, _InputIter __last, _Predicate __pred,
+              _Size& __n) {
+  for ( ; __first != __last; ++__first)
+    if (__pred(*__first))
+      ++__n;
+}
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class _InputIter, class _Tp>
+typename iterator_traits<_InputIter>::difference_type
+count(_InputIter __first, _InputIter __last, const _Tp& __value) {
+  typename iterator_traits<_InputIter>::difference_type __n = 0;
+  for ( ; __first != __last; ++__first)
+    if (*__first == __value)
+      ++__n;
+  return __n;
+}
+
+template <class _InputIter, class _Predicate>
+typename iterator_traits<_InputIter>::difference_type
+count_if(_InputIter __first, _InputIter __last, _Predicate __pred) {
+  typename iterator_traits<_InputIter>::difference_type __n = 0;
+  for ( ; __first != __last; ++__first)
+    if (__pred(*__first))
+      ++__n;
+  return __n;
+}
+
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+// search.
+
+template <class _ForwardIter1, class _ForwardIter2>
+_ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
+                     _ForwardIter2 __first2, _ForwardIter2 __last2) 
+{
+  // Test for empty ranges
+  if (__first1 == __last1 || __first2 == __last2)
+    return __first1;
+
+  // Test for a pattern of length 1.
+  _ForwardIter2 __tmp(__first2);
+  ++__tmp;
+  if (__tmp == __last2)
+    return find(__first1, __last1, *__first2);
+
+  // General case.
+
+  _ForwardIter2 __p1, __p;
+
+  __p1 = __first2; ++__p1;
+
+  _ForwardIter1 __current = __first1;
+
+  while (__first1 != __last1) {
+    __first1 = find(__first1, __last1, *__first2);
+    if (__first1 == __last1)
+      return __last1;
+
+    __p = __p1;
+    __current = __first1; 
+    if (++__current == __last1)
+      return __last1;
+
+    while (*__current == *__p) {
+      if (++__p == __last2)
+        return __first1;
+      if (++__current == __last1)
+        return __last1;
+    }
+
+    ++__first1;
+  }
+  return __first1;
+}
+
+template <class _ForwardIter1, class _ForwardIter2, class _BinaryPred>
+_ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
+                     _ForwardIter2 __first2, _ForwardIter2 __last2,
+                     _BinaryPred  __predicate) 
+{
+  // Test for empty ranges
+  if (__first1 == __last1 || __first2 == __last2)
+    return __first1;
+
+  // Test for a pattern of length 1.
+  _ForwardIter2 __tmp(__first2);
+  ++__tmp;
+  if (__tmp == __last2)
+    return find(__first1, __last1, *__first2);
+
+  // General case.
+
+  _ForwardIter2 __p1, __p;
+
+  __p1 = __first2; ++__p1;
+
+  _ForwardIter1 __current = __first1;
+
+  while (__first1 != __last1) {
+    while (__first1 != __last1) {
+      if (__predicate(*__first1, *__first2))
+        break;
+      ++__first1;
+    }
+    while (__first1 != __last1 && !__predicate(*__first1, *__first2))
+      ++__first1;
+    if (__first1 == __last1)
+      return __last1;
+
+    __p = __p1;
+    __current = __first1; 
+    if (++__current == __last1) return __last1;
+
+    while (__predicate(*__current, *__p)) {
+      if (++__p == __last2)
+        return __first1;
+      if (++__current == __last1)
+        return __last1;
+    }
+
+    ++__first1;
+  }
+  return __first1;
+}
+
+// search_n.  Search for __count consecutive copies of __val.
+
+template <class _ForwardIter, class _Integer, class _Tp>
+_ForwardIter search_n(_ForwardIter __first, _ForwardIter __last,
+                      _Integer __count, const _Tp& __val) {
+  if (__count <= 0)
+    return __first;
+  else {
+    __first = find(__first, __last, __val);
+    while (__first != __last) {
+      _Integer __n = __count - 1;
+      _ForwardIter __i = __first;
+      ++__i;
+      while (__i != __last && __n != 0 && *__i == __val) {
+        ++__i;
+        --__n;
+      }
+      if (__n == 0)
+        return __first;
+      else
+        __first = find(__i, __last, __val);
+    }
+    return __last;
+  }
+}
+
+template <class _ForwardIter, class _Integer, class _Tp, class _BinaryPred>
+_ForwardIter search_n(_ForwardIter __first, _ForwardIter __last,
+                      _Integer __count, const _Tp& __val,
+                      _BinaryPred __binary_pred) {
+  if (__count <= 0)
+    return __first;
+  else {
+    while (__first != __last) {
+      if (__binary_pred(*__first, __val))
+        break;
+      ++__first;
+    }
+    while (__first != __last) {
+      _Integer __n = __count - 1;
+      _ForwardIter __i = __first;
+      ++__i;
+      while (__i != __last && __n != 0 && __binary_pred(*__i, __val)) {
+        ++__i;
+        --__n;
+      }
+      if (__n == 0)
+        return __first;
+      else {
+        while (__i != __last) {
+          if (__binary_pred(*__i, __val))
+            break;
+          ++__i;
+        }
+        __first = __i;
+      }
+    }
+    return __last;
+  }
+} 
+
+// swap_ranges
+
+template <class _ForwardIter1, class _ForwardIter2>
+_ForwardIter2 swap_ranges(_ForwardIter1 __first1, _ForwardIter1 __last1,
+                          _ForwardIter2 __first2) {
+  for ( ; __first1 != __last1; ++__first1, ++__first2)
+    iter_swap(__first1, __first2);
+  return __first2;
+}
+
+// transform
+
+template <class _InputIter, class _OutputIter, class _UnaryOperation>
+_OutputIter transform(_InputIter __first, _InputIter __last,
+                      _OutputIter __result, _UnaryOperation __opr) {
+  for ( ; __first != __last; ++__first, ++__result)
+    *__result = __opr(*__first);
+  return __result;
+}
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+          class _BinaryOperation>
+_OutputIter transform(_InputIter1 __first1, _InputIter1 __last1,
+                      _InputIter2 __first2, _OutputIter __result,
+                      _BinaryOperation __binary_op) {
+  for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result)
+    *__result = __binary_op(*__first1, *__first2);
+  return __result;
+}
+
+// replace, replace_if, replace_copy, replace_copy_if
+
+template <class _ForwardIter, class _Tp>
+void replace(_ForwardIter __first, _ForwardIter __last,
+             const _Tp& __old_value, const _Tp& __new_value) {
+  for ( ; __first != __last; ++__first)
+    if (*__first == __old_value)
+      *__first = __new_value;
+}
+
+template <class _ForwardIter, class _Predicate, class _Tp>
+void replace_if(_ForwardIter __first, _ForwardIter __last,
+                _Predicate __pred, const _Tp& __new_value) {
+  for ( ; __first != __last; ++__first)
+    if (__pred(*__first))
+      *__first = __new_value;
+}
+
+template <class _InputIter, class _OutputIter, class _Tp>
+_OutputIter replace_copy(_InputIter __first, _InputIter __last,
+                         _OutputIter __result,
+                         const _Tp& __old_value, const _Tp& __new_value) {
+  for ( ; __first != __last; ++__first, ++__result)
+    *__result = *__first == __old_value ? __new_value : *__first;
+  return __result;
+}
+
+template <class Iterator, class _OutputIter, class _Predicate, class _Tp>
+_OutputIter replace_copy_if(Iterator __first, Iterator __last,
+                            _OutputIter __result,
+                            _Predicate __pred, const _Tp& __new_value) {
+  for ( ; __first != __last; ++__first, ++__result)
+    *__result = __pred(*__first) ? __new_value : *__first;
+  return __result;
+}
+
+// generate and generate_n
+
+template <class _ForwardIter, class _Generator>
+void generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen) {
+  for ( ; __first != __last; ++__first)
+    *__first = __gen();
+}
+
+template <class _OutputIter, class _Size, class _Generator>
+_OutputIter generate_n(_OutputIter __first, _Size __n, _Generator __gen) {
+  for ( ; __n > 0; --__n, ++__first)
+    *__first = __gen();
+  return __first;
+}
+
+// remove, remove_if, remove_copy, remove_copy_if
+
+template <class _InputIter, class _OutputIter, class _Tp>
+_OutputIter remove_copy(_InputIter __first, _InputIter __last,
+                        _OutputIter __result, const _Tp& __value) {
+  for ( ; __first != __last; ++__first)
+    if (*__first != __value) {
+      *__result = *__first;
+      ++__result;
+    }
+  return __result;
+}
+
+template <class _InputIter, class _OutputIter, class _Predicate>
+_OutputIter remove_copy_if(_InputIter __first, _InputIter __last,
+                           _OutputIter __result, _Predicate __pred) {
+  for ( ; __first != __last; ++__first)
+    if (!__pred(*__first)) {
+      *__result = *__first;
+      ++__result;
+    }
+  return __result;
+}
+
+template <class _ForwardIter, class _Tp>
+_ForwardIter remove(_ForwardIter __first, _ForwardIter __last,
+                    const _Tp& __value) {
+  __first = find(__first, __last, __value);
+  _ForwardIter __i = __first;
+  return __first == __last ? __first 
+                           : remove_copy(++__i, __last, __first, __value);
+}
+
+template <class _ForwardIter, class _Predicate>
+_ForwardIter remove_if(_ForwardIter __first, _ForwardIter __last,
+                       _Predicate __pred) {
+  __first = find_if(__first, __last, __pred);
+  _ForwardIter __i = __first;
+  return __first == __last ? __first 
+                           : remove_copy_if(++__i, __last, __first, __pred);
+}
+
+// unique and unique_copy
+
+template <class _InputIter, class _OutputIter, class _Tp>
+_OutputIter __unique_copy(_InputIter __first, _InputIter __last,
+                          _OutputIter __result, _Tp*) {
+  _Tp __value = *__first;
+  *__result = __value;
+  while (++__first != __last)
+    if (__value != *__first) {
+      __value = *__first;
+      *++__result = __value;
+    }
+  return ++__result;
+}
+
+template <class _InputIter, class _OutputIter>
+inline _OutputIter __unique_copy(_InputIter __first, _InputIter __last,
+                                 _OutputIter __result, 
+                                 output_iterator_tag) {
+  return __unique_copy(__first, __last, __result, __VALUE_TYPE(__first));
+}
+
+template <class _InputIter, class _ForwardIter>
+_ForwardIter __unique_copy(_InputIter __first, _InputIter __last,
+                           _ForwardIter __result, forward_iterator_tag) {
+  *__result = *__first;
+  while (++__first != __last)
+    if (*__result != *__first) *++__result = *__first;
+  return ++__result;
+}
+
+template <class _InputIter, class _OutputIter>
+inline _OutputIter unique_copy(_InputIter __first, _InputIter __last,
+                               _OutputIter __result) {
+  if (__first == __last) return __result;
+  return __unique_copy(__first, __last, __result,
+                       __ITERATOR_CATEGORY(__result));
+}
+
+template <class _InputIter, class _OutputIter, class _BinaryPredicate,
+          class _Tp>
+_OutputIter __unique_copy(_InputIter __first, _InputIter __last,
+                          _OutputIter __result,
+                          _BinaryPredicate __binary_pred, _Tp*) {
+  _Tp __value = *__first;
+  *__result = __value;
+  while (++__first != __last)
+    if (!__binary_pred(__value, *__first)) {
+      __value = *__first;
+      *++__result = __value;
+    }
+  return ++__result;
+}
+
+template <class _InputIter, class _OutputIter, class _BinaryPredicate>
+inline _OutputIter __unique_copy(_InputIter __first, _InputIter __last,
+                                 _OutputIter __result,
+                                 _BinaryPredicate __binary_pred,
+                                 output_iterator_tag) {
+  return __unique_copy(__first, __last, __result, __binary_pred,
+                       __VALUE_TYPE(__first));
+}
+
+template <class _InputIter, class _ForwardIter, class _BinaryPredicate>
+_ForwardIter __unique_copy(_InputIter __first, _InputIter __last,
+                           _ForwardIter __result, 
+                           _BinaryPredicate __binary_pred,
+                           forward_iterator_tag) {
+  *__result = *__first;
+  while (++__first != __last)
+    if (!__binary_pred(*__result, *__first)) *++__result = *__first;
+  return ++__result;
+}
+
+template <class _InputIter, class _OutputIter, class _BinaryPredicate>
+inline _OutputIter unique_copy(_InputIter __first, _InputIter __last,
+                               _OutputIter __result,
+                               _BinaryPredicate __binary_pred) {
+  if (__first == __last) return __result;
+  return __unique_copy(__first, __last, __result, __binary_pred,
+                       __ITERATOR_CATEGORY(__result));
+}
+
+template <class _ForwardIter>
+_ForwardIter unique(_ForwardIter __first, _ForwardIter __last) {
+  __first = adjacent_find(__first, __last);
+  return unique_copy(__first, __last, __first);
+}
+
+template <class _ForwardIter, class _BinaryPredicate>
+_ForwardIter unique(_ForwardIter __first, _ForwardIter __last,
+                    _BinaryPredicate __binary_pred) {
+  __first = adjacent_find(__first, __last, __binary_pred);
+  return unique_copy(__first, __last, __first, __binary_pred);
+}
+
+// reverse and reverse_copy, and their auxiliary functions
+
+template <class _BidirectionalIter>
+void __reverse(_BidirectionalIter __first, _BidirectionalIter __last, 
+               bidirectional_iterator_tag) {
+  while (true)
+    if (__first == __last || __first == --__last)
+      return;
+    else
+      iter_swap(__first++, __last);
+}
+
+template <class _RandomAccessIter>
+void __reverse(_RandomAccessIter __first, _RandomAccessIter __last,
+               random_access_iterator_tag) {
+  while (__first < __last)
+    iter_swap(__first++, --__last);
+}
+
+template <class _BidirectionalIter>
+inline void reverse(_BidirectionalIter __first, _BidirectionalIter __last) {
+  __reverse(__first, __last, __ITERATOR_CATEGORY(__first));
+}
+
+template <class _BidirectionalIter, class _OutputIter>
+_OutputIter reverse_copy(_BidirectionalIter __first,
+                            _BidirectionalIter __last,
+                            _OutputIter __result) {
+  while (__first != __last) {
+    --__last;
+    *__result = *__last;
+    ++__result;
+  }
+  return __result;
+}
+
+// rotate and rotate_copy, and their auxiliary functions
+
+template <class _EuclideanRingElement>
+_EuclideanRingElement __gcd(_EuclideanRingElement __m,
+                            _EuclideanRingElement __n)
+{
+  while (__n != 0) {
+    _EuclideanRingElement __t = __m % __n;
+    __m = __n;
+    __n = __t;
+  }
+  return __m;
+}
+
+template <class _ForwardIter, class _Distance>
+_ForwardIter __rotate(_ForwardIter __first,
+                      _ForwardIter __middle,
+                      _ForwardIter __last,
+                      _Distance*,
+                      forward_iterator_tag) {
+  if (__first == __middle)
+    return __last;
+  if (__last  == __middle)
+    return __first;
+
+  _ForwardIter __first2 = __middle;
+  do {
+    swap(*__first++, *__first2++);
+    if (__first == __middle)
+      __middle = __first2;
+  } while (__first2 != __last);
+
+  _ForwardIter __new_middle = __first;
+
+  __first2 = __middle;
+
+  while (__first2 != __last) {
+    swap (*__first++, *__first2++);
+    if (__first == __middle)
+      __middle = __first2;
+    else if (__first2 == __last)
+      __first2 = __middle;
+  }
+
+  return __new_middle;
+}
+
+
+template <class _BidirectionalIter, class _Distance>
+_BidirectionalIter __rotate(_BidirectionalIter __first,
+                            _BidirectionalIter __middle,
+                            _BidirectionalIter __last,
+                            _Distance*,
+                            bidirectional_iterator_tag) {
+  if (__first == __middle)
+    return __last;
+  if (__last  == __middle)
+    return __first;
+
+  __reverse(__first,  __middle, bidirectional_iterator_tag());
+  __reverse(__middle, __last,   bidirectional_iterator_tag());
+
+  while (__first != __middle && __middle != __last)
+    swap (*__first++, *--__last);
+
+  if (__first == __middle) {
+    __reverse(__middle, __last,   bidirectional_iterator_tag());
+    return __last;
+  }
+  else {
+    __reverse(__first,  __middle, bidirectional_iterator_tag());
+    return __first;
+  }
+}
+
+template <class _RandomAccessIter, class _Distance, class _Tp>
+_RandomAccessIter __rotate(_RandomAccessIter __first,
+                           _RandomAccessIter __middle,
+                           _RandomAccessIter __last,
+                           _Distance *, _Tp *) {
+
+  _Distance __n = __last   - __first;
+  _Distance __k = __middle - __first;
+  _Distance __l = __n - __k;
+  _RandomAccessIter __result = __first + (__last - __middle);
+
+  if (__k == __l) {
+    swap_ranges(__first, __middle, __middle);
+    return __result;
+  }
+
+  _Distance __d = __gcd(__n, __k);
+
+  for (_Distance __i = 0; __i < __d; __i++) {
+    _Tp __tmp = *__first;
+    _RandomAccessIter __p = __first;
+
+    if (__k < __l) {
+      for (_Distance __j = 0; __j < __l/__d; __j++) {
+        if (__p > __first + __l) {
+          *__p = *(__p - __l);
+          __p -= __l;
+        }
+
+        *__p = *(__p + __k);
+        __p += __k;
+      }
+    }
+
+    else {
+      for (_Distance __j = 0; __j < __k/__d - 1; __j ++) {
+        if (__p < __last - __k) {
+          *__p = *(__p + __k);
+          __p += __k;
+        }
+
+        *__p = * (__p - __l);
+        __p -= __l;
+      }
+    }
+
+    *__p = __tmp;
+    ++__first;
+  }
+
+  return __result;
+}
+
+template <class _ForwardIter>
+inline _ForwardIter rotate(_ForwardIter __first, _ForwardIter __middle,
+                           _ForwardIter __last) {
+  return __rotate(__first, __middle, __last,
+                  __DISTANCE_TYPE(__first),
+                  __ITERATOR_CATEGORY(__first));
+}
+
+template <class _ForwardIter, class _OutputIter>
+_OutputIter rotate_copy(_ForwardIter __first, _ForwardIter __middle,
+                            _ForwardIter __last, _OutputIter __result) {
+  return copy(__first, __middle, copy(__middle, __last, __result));
+}
+
+// Return a random number in the range [0, __n).  This function encapsulates
+// whether we're using rand (part of the standard C library) or lrand48
+// (not standard, but a much better choice whenever it's available).
+
+template <class _Distance>
+inline _Distance __random_number(_Distance __n) {
+#ifdef __STL_NO_DRAND48
+  return rand() % __n;
+#else
+  return lrand48() % __n;
+#endif
+}
+
+// random_shuffle
+
+template <class _RandomAccessIter>
+inline void random_shuffle(_RandomAccessIter __first,
+                           _RandomAccessIter __last) {
+  if (__first == __last) return;
+  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
+    iter_swap(__i, __first + __random_number((__i - __first) + 1));
+}
+
+template <class _RandomAccessIter, class _RandomNumberGenerator>
+void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last,
+                    _RandomNumberGenerator& __rand) {
+  if (__first == __last) return;
+  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
+    iter_swap(__i, __first + __rand((__i - __first) + 1));
+}
+
+// random_sample and random_sample_n (extensions, not part of the standard).
+
+template <class _ForwardIter, class _OutputIter, class _Distance>
+_OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last,
+                            _OutputIter __out, const _Distance __n)
+{
+  _Distance __remaining = 0;
+  distance(__first, __last, __remaining);
+  _Distance __m = min(__n, __remaining);
+
+  while (__m > 0) {
+    if (__random_number(__remaining) < __m) {
+      *__out = *__first;
+      ++__out;
+      --__m;
+    }
+
+    --__remaining;
+    ++__first;
+  }
+  return __out;
+}
+
+template <class _ForwardIter, class _OutputIter, class _Distance,
+          class _RandomNumberGenerator>
+_OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last,
+                            _OutputIter __out, const _Distance __n,
+                            _RandomNumberGenerator& __rand)
+{
+  _Distance __remaining = 0;
+  distance(__first, __last, __remaining);
+  _Distance __m = min(__n, __remaining);
+
+  while (__m > 0) {
+    if (__rand(__remaining) < __m) {
+      *__out = *__first;
+      ++__out;
+      --__m;
+    }
+
+    --__remaining;
+    ++__first;
+  }
+  return __out;
+}
+
+template <class _InputIter, class _RandomAccessIter, class _Distance>
+_RandomAccessIter __random_sample(_InputIter __first, _InputIter __last,
+                                  _RandomAccessIter __out,
+                                  const _Distance __n)
+{
+  _Distance __m = 0;
+  _Distance __t = __n;
+  for ( ; __first != __last && __m < __n; ++__m, ++__first) 
+    __out[__m] = *__first;
+
+  while (__first != __last) {
+    ++__t;
+    _Distance __M = __random_number(__t);
+    if (__M < __n)
+      __out[__M] = *__first;
+    ++__first;
+  }
+
+  return __out + __m;
+}
+
+template <class _InputIter, class _RandomAccessIter,
+          class _RandomNumberGenerator, class _Distance>
+_RandomAccessIter __random_sample(_InputIter __first, _InputIter __last,
+                                  _RandomAccessIter __out,
+                                  _RandomNumberGenerator& __rand,
+                                  const _Distance __n)
+{
+  _Distance __m = 0;
+  _Distance __t = __n;
+  for ( ; __first != __last && __m < __n; ++__m, ++__first)
+    __out[__m] = *__first;
+
+  while (__first != __last) {
+    ++__t;
+    _Distance __M = __rand(__t);
+    if (__M < __n)
+      __out[__M] = *__first;
+    ++__first;
+  }
+
+  return __out + __m;
+}
+
+template <class _InputIter, class _RandomAccessIter>
+inline _RandomAccessIter
+random_sample(_InputIter __first, _InputIter __last,
+              _RandomAccessIter __out_first, _RandomAccessIter __out_last) 
+{
+  return __random_sample(__first, __last,
+                         __out_first, __out_last - __out_first);
+}
+
+
+template <class _InputIter, class _RandomAccessIter, 
+          class _RandomNumberGenerator>
+inline _RandomAccessIter
+random_sample(_InputIter __first, _InputIter __last,
+              _RandomAccessIter __out_first, _RandomAccessIter __out_last,
+              _RandomNumberGenerator& __rand) 
+{
+  return __random_sample(__first, __last,
+                         __out_first, __rand,
+                         __out_last - __out_first);
+}
+
+// partition, stable_partition, and their auxiliary functions
+
+template <class _ForwardIter, class _Predicate>
+_ForwardIter __partition(_ForwardIter __first,
+		         _ForwardIter __last,
+			 _Predicate   __pred,
+			 forward_iterator_tag) {
+  if (__first == __last) return __first;
+
+  while (__pred(*__first))
+    if (++__first == __last) return __first;
+
+  _ForwardIter __next = __first;
+
+  while (++__next != __last)
+    if (__pred(*__next)) {
+      swap(*__first, *__next);
+      ++__first;
+    }
+
+  return __first;
+}
+
+template <class _BidirectionalIter, class _Predicate>
+_BidirectionalIter __partition(_BidirectionalIter __first,
+                               _BidirectionalIter __last,
+			       _Predicate __pred,
+			       bidirectional_iterator_tag) {
+  while (true) {
+    while (true)
+      if (__first == __last)
+        return __first;
+      else if (__pred(*__first))
+        ++__first;
+      else
+        break;
+    --__last;
+    while (true)
+      if (__first == __last)
+        return __first;
+      else if (!__pred(*__last))
+        --__last;
+      else
+        break;
+    iter_swap(__first, __last);
+    ++__first;
+  }
+}
+
+template <class _ForwardIter, class _Predicate>
+inline _ForwardIter partition(_ForwardIter __first,
+   			      _ForwardIter __last,
+			      _Predicate   __pred) {
+  return __partition(__first, __last, __pred, __ITERATOR_CATEGORY(__first));
+}
+
+
+template <class _ForwardIter, class _Predicate, class _Distance>
+_ForwardIter __inplace_stable_partition(_ForwardIter __first,
+                                        _ForwardIter __last,
+                                        _Predicate __pred, _Distance __len) {
+  if (__len == 1)
+    return __pred(*__first) ? __last : __first;
+  _ForwardIter __middle = __first;
+  advance(__middle, __len / 2);
+  return rotate(__inplace_stable_partition(__first, __middle, __pred, 
+                                           __len / 2),
+                __middle,
+                __inplace_stable_partition(__middle, __last, __pred,
+                                           __len - __len / 2));
+}
+
+template <class _ForwardIter, class _Pointer, class _Predicate, 
+          class _Distance>
+_ForwardIter __stable_partition_adaptive(_ForwardIter __first,
+                                         _ForwardIter __last,
+                                         _Predicate __pred, _Distance __len,
+                                         _Pointer __buffer,
+                                         _Distance __buffer_size) 
+{
+  if (__len <= __buffer_size) {
+    _ForwardIter __result1 = __first;
+    _Pointer __result2 = __buffer;
+    for ( ; __first != __last ; ++__first)
+      if (__pred(*__first)) {
+        *__result1 = *__first;
+        ++__result1;
+      }
+      else {
+        *__result2 = *__first;
+        ++__result2;
+      }
+    copy(__buffer, __result2, __result1);
+    return __result1;
+  }
+  else {
+    _ForwardIter __middle = __first;
+    advance(__middle, __len / 2);
+    return rotate(__stable_partition_adaptive(
+                          __first, __middle, __pred,
+                          __len / 2, __buffer, __buffer_size),
+                    __middle,
+                    __stable_partition_adaptive(
+                          __middle, __last, __pred,
+                          __len - __len / 2, __buffer, __buffer_size));
+  }
+}
+
+template <class _ForwardIter, class _Predicate, class _Tp, class _Distance>
+inline _ForwardIter
+__stable_partition_aux(_ForwardIter __first, _ForwardIter __last, 
+                       _Predicate __pred, _Tp*, _Distance*)
+{
+  _Temporary_buffer<_ForwardIter, _Tp> __buf(__first, __last);
+  if (__buf.size() > 0)
+    return __stable_partition_adaptive(__first, __last, __pred,
+                                       _Distance(__buf.requested_size()),
+                                       __buf.begin(), __buf.size());
+  else
+    return __inplace_stable_partition(__first, __last, __pred, 
+                                      _Distance(__buf.requested_size()));
+}
+
+template <class _ForwardIter, class _Predicate>
+inline _ForwardIter stable_partition(_ForwardIter __first,
+                                     _ForwardIter __last, 
+                                     _Predicate __pred) {
+  if (__first == __last)
+    return __first;
+  else
+    return __stable_partition_aux(__first, __last, __pred,
+                                  __VALUE_TYPE(__first),
+                                  __DISTANCE_TYPE(__first));
+}
+
+template <class _RandomAccessIter, class _Tp>
+_RandomAccessIter __unguarded_partition(_RandomAccessIter __first, 
+                                        _RandomAccessIter __last, 
+                                        _Tp __pivot) 
+{
+  while (true) {
+    while (*__first < __pivot)
+      ++__first;
+    --__last;
+    while (__pivot < *__last)
+      --__last;
+    if (!(__first < __last))
+      return __first;
+    iter_swap(__first, __last);
+    ++__first;
+  }
+}    
+
+template <class _RandomAccessIter, class _Tp, class _Compare>
+_RandomAccessIter __unguarded_partition(_RandomAccessIter __first, 
+                                        _RandomAccessIter __last, 
+                                        _Tp __pivot, _Compare __comp) 
+{
+  while (true) {
+    while (__comp(*__first, __pivot))
+      ++__first;
+    --__last;
+    while (__comp(__pivot, *__last))
+      --__last;
+    if (!(__first < __last))
+      return __first;
+    iter_swap(__first, __last);
+    ++__first;
+  }
+}
+
+const int __stl_threshold = 16;
+
+// sort() and its auxiliary functions. 
+
+template <class _RandomAccessIter, class _Tp>
+void __unguarded_linear_insert(_RandomAccessIter __last, _Tp __val) {
+  _RandomAccessIter __next = __last;
+  --__next;
+  while (__val < *__next) {
+    *__last = *__next;
+    __last = __next;
+    --__next;
+  }
+  *__last = __val;
+}
+
+template <class _RandomAccessIter, class _Tp, class _Compare>
+void __unguarded_linear_insert(_RandomAccessIter __last, _Tp __val, 
+                               _Compare __comp) {
+  _RandomAccessIter __next = __last;
+  --__next;  
+  while (__comp(__val, *__next)) {
+    *__last = *__next;
+    __last = __next;
+    --__next;
+  }
+  *__last = __val;
+}
+
+template <class _RandomAccessIter, class _Tp>
+inline void __linear_insert(_RandomAccessIter __first, 
+                            _RandomAccessIter __last, _Tp*) {
+  _Tp __val = *__last;
+  if (__val < *__first) {
+    copy_backward(__first, __last, __last + 1);
+    *__first = __val;
+  }
+  else
+    __unguarded_linear_insert(__last, __val);
+}
+
+template <class _RandomAccessIter, class _Tp, class _Compare>
+inline void __linear_insert(_RandomAccessIter __first, 
+                            _RandomAccessIter __last, _Tp*, _Compare __comp) {
+  _Tp __val = *__last;
+  if (__comp(__val, *__first)) {
+    copy_backward(__first, __last, __last + 1);
+    *__first = __val;
+  }
+  else
+    __unguarded_linear_insert(__last, __val, __comp);
+}
+
+template <class _RandomAccessIter>
+void __insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last) {
+  if (__first == __last) return; 
+  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
+    __linear_insert(__first, __i, __VALUE_TYPE(__first));
+}
+
+template <class _RandomAccessIter, class _Compare>
+void __insertion_sort(_RandomAccessIter __first,
+                      _RandomAccessIter __last, _Compare __comp) {
+  if (__first == __last) return;
+  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
+    __linear_insert(__first, __i, __VALUE_TYPE(__first), __comp);
+}
+
+template <class _RandomAccessIter, class _Tp>
+void __unguarded_insertion_sort_aux(_RandomAccessIter __first, 
+                                    _RandomAccessIter __last, _Tp*) {
+  for (_RandomAccessIter __i = __first; __i != __last; ++__i)
+    __unguarded_linear_insert(__i, _Tp(*__i));
+}
+
+template <class _RandomAccessIter>
+inline void __unguarded_insertion_sort(_RandomAccessIter __first, 
+                                _RandomAccessIter __last) {
+  __unguarded_insertion_sort_aux(__first, __last, __VALUE_TYPE(__first));
+}
+
+template <class _RandomAccessIter, class _Tp, class _Compare>
+void __unguarded_insertion_sort_aux(_RandomAccessIter __first, 
+                                    _RandomAccessIter __last,
+                                    _Tp*, _Compare __comp) {
+  for (_RandomAccessIter __i = __first; __i != __last; ++__i)
+    __unguarded_linear_insert(__i, _Tp(*__i), __comp);
+}
+
+template <class _RandomAccessIter, class _Compare>
+inline void __unguarded_insertion_sort(_RandomAccessIter __first, 
+                                       _RandomAccessIter __last,
+                                       _Compare __comp) {
+  __unguarded_insertion_sort_aux(__first, __last, __VALUE_TYPE(__first),
+                                 __comp);
+}
+
+template <class _RandomAccessIter>
+void __final_insertion_sort(_RandomAccessIter __first, 
+                            _RandomAccessIter __last) {
+  if (__last - __first > __stl_threshold) {
+    __insertion_sort(__first, __first + __stl_threshold);
+    __unguarded_insertion_sort(__first + __stl_threshold, __last);
+  }
+  else
+    __insertion_sort(__first, __last);
+}
+
+template <class _RandomAccessIter, class _Compare>
+void __final_insertion_sort(_RandomAccessIter __first, 
+                            _RandomAccessIter __last, _Compare __comp) {
+  if (__last - __first > __stl_threshold) {
+    __insertion_sort(__first, __first + __stl_threshold, __comp);
+    __unguarded_insertion_sort(__first + __stl_threshold, __last, __comp);
+  }
+  else
+    __insertion_sort(__first, __last, __comp);
+}
+
+template <class _Size>
+inline _Size __lg(_Size __n) {
+  _Size __k;
+  for (__k = 0; __n != 1; __n >>= 1) ++__k;
+  return __k;
+}
+
+template <class _RandomAccessIter, class _Tp, class _Size>
+void __introsort_loop(_RandomAccessIter __first,
+                      _RandomAccessIter __last, _Tp*,
+                      _Size __depth_limit)
+{
+  while (__last - __first > __stl_threshold) {
+    if (__depth_limit == 0) {
+      partial_sort(__first, __last, __last);
+      return;
+    }
+    --__depth_limit;
+    _RandomAccessIter __cut =
+      __unguarded_partition(__first, __last,
+                            _Tp(__median(*__first,
+                                         *(__first + (__last - __first)/2),
+                                         *(__last - 1))));
+    __introsort_loop(__cut, __last, (_Tp*) 0, __depth_limit);
+    __last = __cut;
+  }
+}
+
+template <class _RandomAccessIter, class _Tp, class _Size, class _Compare>
+void __introsort_loop(_RandomAccessIter __first,
+                      _RandomAccessIter __last, _Tp*,
+                      _Size __depth_limit, _Compare __comp)
+{
+  while (__last - __first > __stl_threshold) {
+    if (__depth_limit == 0) {
+      partial_sort(__first, __last, __last, __comp);
+      return;
+    }
+    --__depth_limit;
+    _RandomAccessIter __cut =
+      __unguarded_partition(__first, __last,
+                            _Tp(__median(*__first,
+                                         *(__first + (__last - __first)/2),
+                                         *(__last - 1), __comp)),
+       __comp);
+    __introsort_loop(__cut, __last, (_Tp*) 0, __depth_limit, __comp);
+    __last = __cut;
+  }
+}
+
+template <class _RandomAccessIter>
+inline void sort(_RandomAccessIter __first, _RandomAccessIter __last) {
+  if (__first != __last) {
+    __introsort_loop(__first, __last,
+                     __VALUE_TYPE(__first),
+                     __lg(__last - __first) * 2);
+    __final_insertion_sort(__first, __last);
+  }
+}
+
+template <class _RandomAccessIter, class _Compare>
+inline void sort(_RandomAccessIter __first, _RandomAccessIter __last,
+                 _Compare __comp) {
+  if (__first != __last) {
+    __introsort_loop(__first, __last,
+                     __VALUE_TYPE(__first),
+                     __lg(__last - __first) * 2,
+                     __comp);
+    __final_insertion_sort(__first, __last, __comp);
+  }
+}
+
+// stable_sort() and its auxiliary functions.
+
+template <class _RandomAccessIter>
+void __inplace_stable_sort(_RandomAccessIter __first,
+                           _RandomAccessIter __last) {
+  if (__last - __first < 15) {
+    __insertion_sort(__first, __last);
+    return;
+  }
+  _RandomAccessIter __middle = __first + (__last - __first) / 2;
+  __inplace_stable_sort(__first, __middle);
+  __inplace_stable_sort(__middle, __last);
+  __merge_without_buffer(__first, __middle, __last,
+                         __middle - __first,
+                         __last - __middle);
+}
+
+template <class _RandomAccessIter, class _Compare>
+void __inplace_stable_sort(_RandomAccessIter __first,
+                           _RandomAccessIter __last, _Compare __comp) {
+  if (__last - __first < 15) {
+    __insertion_sort(__first, __last, __comp);
+    return;
+  }
+  _RandomAccessIter __middle = __first + (__last - __first) / 2;
+  __inplace_stable_sort(__first, __middle, __comp);
+  __inplace_stable_sort(__middle, __last, __comp);
+  __merge_without_buffer(__first, __middle, __last,
+                         __middle - __first,
+                         __last - __middle,
+                         __comp);
+}
+
+template <class _RandomAccessIter1, class _RandomAccessIter2,
+          class _Distance>
+void __merge_sort_loop(_RandomAccessIter1 __first,
+                       _RandomAccessIter1 __last, 
+                       _RandomAccessIter2 __result, _Distance __step_size) {
+  _Distance __two_step = 2 * __step_size;
+
+  while (__last - __first >= __two_step) {
+    __result = merge(__first, __first + __step_size,
+                     __first + __step_size, __first + __two_step,
+                     __result);
+    __first += __two_step;
+  }
+
+  __step_size = min(_Distance(__last - __first), __step_size);
+  merge(__first, __first + __step_size, __first + __step_size, __last,
+        __result);
+}
+
+template <class _RandomAccessIter1, class _RandomAccessIter2,
+          class _Distance, class _Compare>
+void __merge_sort_loop(_RandomAccessIter1 __first,
+                       _RandomAccessIter1 __last, 
+                       _RandomAccessIter2 __result, _Distance __step_size,
+                       _Compare __comp) {
+  _Distance __two_step = 2 * __step_size;
+
+  while (__last - __first >= __two_step) {
+    __result = merge(__first, __first + __step_size,
+                     __first + __step_size, __first + __two_step,
+                     __result,
+                     __comp);
+    __first += __two_step;
+  }
+  __step_size = min(_Distance(__last - __first), __step_size);
+
+  merge(__first, __first + __step_size,
+        __first + __step_size, __last,
+        __result,
+        __comp);
+}
+
+const int __stl_chunk_size = 7;
+        
+template <class _RandomAccessIter, class _Distance>
+void __chunk_insertion_sort(_RandomAccessIter __first, 
+                            _RandomAccessIter __last, _Distance __chunk_size)
+{
+  while (__last - __first >= __chunk_size) {
+    __insertion_sort(__first, __first + __chunk_size);
+    __first += __chunk_size;
+  }
+  __insertion_sort(__first, __last);
+}
+
+template <class _RandomAccessIter, class _Distance, class _Compare>
+void __chunk_insertion_sort(_RandomAccessIter __first, 
+                            _RandomAccessIter __last,
+                            _Distance __chunk_size, _Compare __comp)
+{
+  while (__last - __first >= __chunk_size) {
+    __insertion_sort(__first, __first + __chunk_size, __comp);
+    __first += __chunk_size;
+  }
+  __insertion_sort(__first, __last, __comp);
+}
+
+template <class _RandomAccessIter, class _Pointer, class _Distance>
+void __merge_sort_with_buffer(_RandomAccessIter __first, 
+                              _RandomAccessIter __last,
+                              _Pointer __buffer, _Distance*) {
+  _Distance __len = __last - __first;
+  _Pointer __buffer_last = __buffer + __len;
+
+  _Distance __step_size = __stl_chunk_size;
+  __chunk_insertion_sort(__first, __last, __step_size);
+
+  while (__step_size < __len) {
+    __merge_sort_loop(__first, __last, __buffer, __step_size);
+    __step_size *= 2;
+    __merge_sort_loop(__buffer, __buffer_last, __first, __step_size);
+    __step_size *= 2;
+  }
+}
+
+template <class _RandomAccessIter, class _Pointer, class _Distance,
+          class _Compare>
+void __merge_sort_with_buffer(_RandomAccessIter __first, 
+                              _RandomAccessIter __last, _Pointer __buffer,
+                              _Distance*, _Compare __comp) {
+  _Distance __len = __last - __first;
+  _Pointer __buffer_last = __buffer + __len;
+
+  _Distance __step_size = __stl_chunk_size;
+  __chunk_insertion_sort(__first, __last, __step_size, __comp);
+
+  while (__step_size < __len) {
+    __merge_sort_loop(__first, __last, __buffer, __step_size, __comp);
+    __step_size *= 2;
+    __merge_sort_loop(__buffer, __buffer_last, __first, __step_size, __comp);
+    __step_size *= 2;
+  }
+}
+
+template <class _RandomAccessIter, class _Pointer, class _Distance>
+void __stable_sort_adaptive(_RandomAccessIter __first, 
+                            _RandomAccessIter __last, _Pointer __buffer,
+                            _Distance __buffer_size) {
+  _Distance __len = (__last - __first + 1) / 2;
+  _RandomAccessIter __middle = __first + __len;
+  if (__len > __buffer_size) {
+    __stable_sort_adaptive(__first, __middle, __buffer, __buffer_size);
+    __stable_sort_adaptive(__middle, __last, __buffer, __buffer_size);
+  }
+  else {
+    __merge_sort_with_buffer(__first, __middle, __buffer, (_Distance*)0);
+    __merge_sort_with_buffer(__middle, __last, __buffer, (_Distance*)0);
+  }
+  __merge_adaptive(__first, __middle, __last, _Distance(__middle - __first), 
+                   _Distance(__last - __middle), __buffer, __buffer_size);
+}
+
+template <class _RandomAccessIter, class _Pointer, class _Distance, 
+          class _Compare>
+void __stable_sort_adaptive(_RandomAccessIter __first, 
+                            _RandomAccessIter __last, _Pointer __buffer,
+                            _Distance __buffer_size, _Compare __comp) {
+  _Distance __len = (__last - __first + 1) / 2;
+  _RandomAccessIter __middle = __first + __len;
+  if (__len > __buffer_size) {
+    __stable_sort_adaptive(__first, __middle, __buffer, __buffer_size, 
+                           __comp);
+    __stable_sort_adaptive(__middle, __last, __buffer, __buffer_size, 
+                           __comp);
+  }
+  else {
+    __merge_sort_with_buffer(__first, __middle, __buffer, (_Distance*)0,
+                               __comp);
+    __merge_sort_with_buffer(__middle, __last, __buffer, (_Distance*)0,
+                               __comp);
+  }
+  __merge_adaptive(__first, __middle, __last, _Distance(__middle - __first), 
+                   _Distance(__last - __middle), __buffer, __buffer_size,
+                   __comp);
+}
+
+template <class _RandomAccessIter, class _Tp, class _Distance>
+inline void __stable_sort_aux(_RandomAccessIter __first,
+                              _RandomAccessIter __last, _Tp*, _Distance*) {
+  _Temporary_buffer<_RandomAccessIter, _Tp> buf(__first, __last);
+  if (buf.begin() == 0)
+    __inplace_stable_sort(__first, __last);
+  else 
+    __stable_sort_adaptive(__first, __last, buf.begin(),
+                           _Distance(buf.size()));
+}
+
+template <class _RandomAccessIter, class _Tp, class _Distance, class _Compare>
+inline void __stable_sort_aux(_RandomAccessIter __first,
+                              _RandomAccessIter __last, _Tp*, _Distance*,
+                              _Compare __comp) {
+  _Temporary_buffer<_RandomAccessIter, _Tp> buf(__first, __last);
+  if (buf.begin() == 0)
+    __inplace_stable_sort(__first, __last, __comp);
+  else 
+    __stable_sort_adaptive(__first, __last, buf.begin(),
+                           _Distance(buf.size()),
+                           __comp);
+}
+
+template <class _RandomAccessIter>
+inline void stable_sort(_RandomAccessIter __first,
+                        _RandomAccessIter __last) {
+  __stable_sort_aux(__first, __last,
+                    __VALUE_TYPE(__first),
+                    __DISTANCE_TYPE(__first));
+}
+
+template <class _RandomAccessIter, class _Compare>
+inline void stable_sort(_RandomAccessIter __first,
+                        _RandomAccessIter __last, _Compare __comp) {
+  __stable_sort_aux(__first, __last,
+                    __VALUE_TYPE(__first),
+                    __DISTANCE_TYPE(__first), 
+                    __comp);
+}
+
+// partial_sort, partial_sort_copy, and auxiliary functions.
+
+template <class _RandomAccessIter, class _Tp>
+void __partial_sort(_RandomAccessIter __first, _RandomAccessIter __middle,
+                    _RandomAccessIter __last, _Tp*) {
+  make_heap(__first, __middle);
+  for (_RandomAccessIter __i = __middle; __i < __last; ++__i)
+    if (*__i < *__first) 
+      __pop_heap(__first, __middle, __i, _Tp(*__i),
+                 __DISTANCE_TYPE(__first));
+  sort_heap(__first, __middle);
+}
+
+template <class _RandomAccessIter>
+inline void partial_sort(_RandomAccessIter __first,
+                         _RandomAccessIter __middle,
+                         _RandomAccessIter __last) {
+  __partial_sort(__first, __middle, __last, __VALUE_TYPE(__first));
+}
+
+template <class _RandomAccessIter, class _Tp, class _Compare>
+void __partial_sort(_RandomAccessIter __first, _RandomAccessIter __middle,
+                    _RandomAccessIter __last, _Tp*, _Compare __comp) {
+  make_heap(__first, __middle, __comp);
+  for (_RandomAccessIter __i = __middle; __i < __last; ++__i)
+    if (__comp(*__i, *__first))
+      __pop_heap(__first, __middle, __i, _Tp(*__i), __comp,
+                 __DISTANCE_TYPE(__first));
+  sort_heap(__first, __middle, __comp);
+}
+
+template <class _RandomAccessIter, class _Compare>
+inline void partial_sort(_RandomAccessIter __first,
+                         _RandomAccessIter __middle,
+                         _RandomAccessIter __last, _Compare __comp) {
+  __partial_sort(__first, __middle, __last, __VALUE_TYPE(__first), __comp);
+}
+
+template <class _InputIter, class _RandomAccessIter, class _Distance,
+          class _Tp>
+_RandomAccessIter __partial_sort_copy(_InputIter __first,
+                                         _InputIter __last,
+                                         _RandomAccessIter __result_first,
+                                         _RandomAccessIter __result_last, 
+                                         _Distance*, _Tp*) {
+  if (__result_first == __result_last) return __result_last;
+  _RandomAccessIter __result_real_last = __result_first;
+  while(__first != __last && __result_real_last != __result_last) {
+    *__result_real_last = *__first;
+    ++__result_real_last;
+    ++__first;
+  }
+  make_heap(__result_first, __result_real_last);
+  while (__first != __last) {
+    if (*__first < *__result_first) 
+      __adjust_heap(__result_first, _Distance(0),
+                    _Distance(__result_real_last - __result_first),
+                    _Tp(*__first));
+    ++__first;
+  }
+  sort_heap(__result_first, __result_real_last);
+  return __result_real_last;
+}
+
+template <class _InputIter, class _RandomAccessIter>
+inline _RandomAccessIter
+partial_sort_copy(_InputIter __first, _InputIter __last,
+                  _RandomAccessIter __result_first,
+                  _RandomAccessIter __result_last) {
+  return __partial_sort_copy(__first, __last, __result_first, __result_last, 
+                             __DISTANCE_TYPE(__result_first),
+                             __VALUE_TYPE(__first));
+}
+
+template <class _InputIter, class _RandomAccessIter, class _Compare,
+          class _Distance, class _Tp>
+_RandomAccessIter __partial_sort_copy(_InputIter __first,
+                                         _InputIter __last,
+                                         _RandomAccessIter __result_first,
+                                         _RandomAccessIter __result_last,
+                                         _Compare __comp, _Distance*, _Tp*) {
+  if (__result_first == __result_last) return __result_last;
+  _RandomAccessIter __result_real_last = __result_first;
+  while(__first != __last && __result_real_last != __result_last) {
+    *__result_real_last = *__first;
+    ++__result_real_last;
+    ++__first;
+  }
+  make_heap(__result_first, __result_real_last, __comp);
+  while (__first != __last) {
+    if (__comp(*__first, *__result_first))
+      __adjust_heap(__result_first, _Distance(0),
+                    _Distance(__result_real_last - __result_first),
+                    _Tp(*__first),
+                    __comp);
+    ++__first;
+  }
+  sort_heap(__result_first, __result_real_last, __comp);
+  return __result_real_last;
+}
+
+template <class _InputIter, class _RandomAccessIter, class _Compare>
+inline _RandomAccessIter
+partial_sort_copy(_InputIter __first, _InputIter __last,
+                  _RandomAccessIter __result_first,
+                  _RandomAccessIter __result_last, _Compare __comp) {
+  return __partial_sort_copy(__first, __last, __result_first, __result_last,
+                             __comp,
+                             __DISTANCE_TYPE(__result_first),
+                             __VALUE_TYPE(__first));
+}
+
+// nth_element() and its auxiliary functions.  
+
+template <class _RandomAccessIter, class _Tp>
+void __nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
+                   _RandomAccessIter __last, _Tp*) {
+  while (__last - __first > 3) {
+    _RandomAccessIter __cut =
+      __unguarded_partition(__first, __last,
+                            _Tp(__median(*__first,
+                                         *(__first + (__last - __first)/2),
+                                         *(__last - 1))));
+    if (__cut <= __nth)
+      __first = __cut;
+    else 
+      __last = __cut;
+  }
+  __insertion_sort(__first, __last);
+}
+
+template <class _RandomAccessIter>
+inline void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
+                        _RandomAccessIter __last) {
+  __nth_element(__first, __nth, __last, __VALUE_TYPE(__first));
+}
+
+template <class _RandomAccessIter, class _Tp, class _Compare>
+void __nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
+                   _RandomAccessIter __last, _Tp*, _Compare __comp) {
+  while (__last - __first > 3) {
+    _RandomAccessIter __cut =
+      __unguarded_partition(__first, __last,
+                            _Tp(__median(*__first,
+                                         *(__first + (__last - __first)/2), 
+                                         *(__last - 1),
+                                         __comp)),
+                            __comp);
+    if (__cut <= __nth)
+      __first = __cut;
+    else 
+      __last = __cut;
+  }
+  __insertion_sort(__first, __last, __comp);
+}
+
+template <class _RandomAccessIter, class _Compare>
+inline void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
+                 _RandomAccessIter __last, _Compare __comp) {
+  __nth_element(__first, __nth, __last, __VALUE_TYPE(__first), __comp);
+}
+
+
+// Binary search (lower_bound, upper_bound, equal_range, binary_search).
+
+template <class _ForwardIter, class _Tp, class _Distance>
+_ForwardIter __lower_bound(_ForwardIter __first, _ForwardIter __last,
+                           const _Tp& __val, _Distance*) 
+{
+  _Distance __len = 0;
+  distance(__first, __last, __len);
+  _Distance __half;
+  _ForwardIter __middle;
+
+  while (__len > 0) {
+    __half = __len >> 1;
+    __middle = __first;
+    advance(__middle, __half);
+    if (*__middle < __val) {
+      __first = __middle;
+      ++__first;
+      __len = __len - __half - 1;
+    }
+    else
+      __len = __half;
+  }
+  return __first;
+}
+
+template <class _ForwardIter, class _Tp>
+inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last,
+                                   const _Tp& __val) {
+  return __lower_bound(__first, __last, __val,
+                       __DISTANCE_TYPE(__first));
+}
+
+template <class _ForwardIter, class _Tp, class _Compare, class _Distance>
+_ForwardIter __lower_bound(_ForwardIter __first, _ForwardIter __last,
+                              const _Tp& __val, _Compare __comp, _Distance*)
+{
+  _Distance __len = 0;
+  distance(__first, __last, __len);
+  _Distance __half;
+  _ForwardIter __middle;
+
+  while (__len > 0) {
+    __half = __len >> 1;
+    __middle = __first;
+    advance(__middle, __half);
+    if (__comp(*__middle, __val)) {
+      __first = __middle;
+      ++__first;
+      __len = __len - __half - 1;
+    }
+    else
+      __len = __half;
+  }
+  return __first;
+}
+
+template <class _ForwardIter, class _Tp, class _Compare>
+inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last,
+                                const _Tp& __val, _Compare __comp) {
+  return __lower_bound(__first, __last, __val, __comp,
+                       __DISTANCE_TYPE(__first));
+}
+
+template <class _ForwardIter, class _Tp, class _Distance>
+_ForwardIter __upper_bound(_ForwardIter __first, _ForwardIter __last,
+                           const _Tp& __val, _Distance*)
+{
+  _Distance __len = 0;
+  distance(__first, __last, __len);
+  _Distance __half;
+  _ForwardIter __middle;
+
+  while (__len > 0) {
+    __half = __len >> 1;
+    __middle = __first;
+    advance(__middle, __half);
+    if (__val < *__middle)
+      __len = __half;
+    else {
+      __first = __middle;
+      ++__first;
+      __len = __len - __half - 1;
+    }
+  }
+  return __first;
+}
+
+template <class _ForwardIter, class _Tp>
+inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last,
+                                const _Tp& __val) {
+  return __upper_bound(__first, __last, __val,
+                       __DISTANCE_TYPE(__first));
+}
+
+template <class _ForwardIter, class _Tp, class _Compare, class _Distance>
+_ForwardIter __upper_bound(_ForwardIter __first, _ForwardIter __last,
+                           const _Tp& __val, _Compare __comp, _Distance*)
+{
+  _Distance __len = 0;
+  distance(__first, __last, __len);
+  _Distance __half;
+  _ForwardIter __middle;
+
+  while (__len > 0) {
+    __half = __len >> 1;
+    __middle = __first;
+    advance(__middle, __half);
+    if (__comp(__val, *__middle))
+      __len = __half;
+    else {
+      __first = __middle;
+      ++__first;
+      __len = __len - __half - 1;
+    }
+  }
+  return __first;
+}
+
+template <class _ForwardIter, class _Tp, class _Compare>
+inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last,
+                                const _Tp& __val, _Compare __comp) {
+  return __upper_bound(__first, __last, __val, __comp,
+                       __DISTANCE_TYPE(__first));
+}
+
+template <class _ForwardIter, class _Tp, class _Distance>
+pair<_ForwardIter, _ForwardIter>
+__equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+              _Distance*)
+{
+  _Distance __len = 0;
+  distance(__first, __last, __len);
+  _Distance __half;
+  _ForwardIter __middle, __left, __right;
+
+  while (__len > 0) {
+    __half = __len >> 1;
+    __middle = __first;
+    advance(__middle, __half);
+    if (*__middle < __val) {
+      __first = __middle;
+      ++__first;
+      __len = __len - __half - 1;
+    }
+    else if (__val < *__middle)
+      __len = __half;
+    else {
+      __left = lower_bound(__first, __middle, __val);
+      advance(__first, __len);
+      __right = upper_bound(++__middle, __first, __val);
+      return pair<_ForwardIter, _ForwardIter>(__left, __right);
+    }
+  }
+  return pair<_ForwardIter, _ForwardIter>(__first, __first);
+}
+
+template <class _ForwardIter, class _Tp>
+inline pair<_ForwardIter, _ForwardIter>
+equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) {
+  return __equal_range(__first, __last, __val,
+                       __DISTANCE_TYPE(__first));
+}
+
+template <class _ForwardIter, class _Tp, class _Compare, class _Distance>
+pair<_ForwardIter, _ForwardIter>
+__equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+              _Compare __comp, _Distance*)
+{
+  _Distance __len = 0;
+  distance(__first, __last, __len);
+  _Distance __half;
+  _ForwardIter __middle, __left, __right;
+
+  while (__len > 0) {
+    __half = __len >> 1;
+    __middle = __first;
+    advance(__middle, __half);
+    if (__comp(*__middle, __val)) {
+      __first = __middle;
+      ++__first;
+      __len = __len - __half - 1;
+    }
+    else if (__comp(__val, *__middle))
+      __len = __half;
+    else {
+      __left = lower_bound(__first, __middle, __val, __comp);
+      advance(__first, __len);
+      __right = upper_bound(++__middle, __first, __val, __comp);
+      return pair<_ForwardIter, _ForwardIter>(__left, __right);
+    }
+  }
+  return pair<_ForwardIter, _ForwardIter>(__first, __first);
+}           
+
+template <class _ForwardIter, class _Tp, class _Compare>
+inline pair<_ForwardIter, _ForwardIter>
+equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+            _Compare __comp) {
+  return __equal_range(__first, __last, __val, __comp,
+                       __DISTANCE_TYPE(__first));
+} 
+
+template <class _ForwardIter, class _Tp>
+bool binary_search(_ForwardIter __first, _ForwardIter __last,
+                   const _Tp& __val) {
+  _ForwardIter __i = lower_bound(__first, __last, __val);
+  return __i != __last && !(__val < *__i);
+}
+
+template <class _ForwardIter, class _Tp, class _Compare>
+bool binary_search(_ForwardIter __first, _ForwardIter __last,
+                   const _Tp& __val,
+                   _Compare __comp) {
+  _ForwardIter __i = lower_bound(__first, __last, __val, __comp);
+  return __i != __last && !__comp(__val, *__i);
+}
+
+// merge, with and without an explicitly supplied comparison function.
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,
+                  _InputIter2 __first2, _InputIter2 __last2,
+                  _OutputIter __result) {
+  while (__first1 != __last1 && __first2 != __last2) {
+    if (*__first2 < *__first1) {
+      *__result = *__first2;
+      ++__first2;
+    }
+    else {
+      *__result = *__first1;
+      ++__first1;
+    }
+    ++__result;
+  }
+  return copy(__first2, __last2, copy(__first1, __last1, __result));
+}
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+          class _Compare>
+_OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,
+                  _InputIter2 __first2, _InputIter2 __last2,
+                  _OutputIter __result, _Compare __comp) {
+  while (__first1 != __last1 && __first2 != __last2) {
+    if (__comp(*__first2, *__first1)) {
+      *__result = *__first2;
+      ++__first2;
+    }
+    else {
+      *__result = *__first1;
+      ++__first1;
+    }
+    ++__result;
+  }
+  return copy(__first2, __last2, copy(__first1, __last1, __result));
+}
+
+// inplace_merge and its auxiliary functions. 
+
+template <class _BidirectionalIter, class _Distance>
+void __merge_without_buffer(_BidirectionalIter __first,
+                            _BidirectionalIter __middle,
+                            _BidirectionalIter __last,
+                            _Distance __len1, _Distance __len2) {
+  if (__len1 == 0 || __len2 == 0)
+    return;
+  if (__len1 + __len2 == 2) {
+    if (*__middle < *__first)
+      iter_swap(__first, __middle);
+    return;
+  }
+  _BidirectionalIter __first_cut = __first;
+  _BidirectionalIter __second_cut = __middle;
+  _Distance __len11 = 0;
+  _Distance __len22 = 0;
+  if (__len1 > __len2) {
+    __len11 = __len1 / 2;
+    advance(__first_cut, __len11);
+    __second_cut = lower_bound(__middle, __last, *__first_cut);
+    distance(__middle, __second_cut, __len22);
+  }
+  else {
+    __len22 = __len2 / 2;
+    advance(__second_cut, __len22);
+    __first_cut = upper_bound(__first, __middle, *__second_cut);
+    distance(__first, __first_cut, __len11);
+  }
+  _BidirectionalIter __new_middle
+    = rotate(__first_cut, __middle, __second_cut);
+  __merge_without_buffer(__first, __first_cut, __new_middle,
+                         __len11, __len22);
+  __merge_without_buffer(__new_middle, __second_cut, __last, __len1 - __len11,
+                         __len2 - __len22);
+}
+
+template <class _BidirectionalIter, class _Distance, class _Compare>
+void __merge_without_buffer(_BidirectionalIter __first,
+                            _BidirectionalIter __middle,
+                            _BidirectionalIter __last,
+                            _Distance __len1, _Distance __len2,
+                            _Compare __comp) {
+  if (__len1 == 0 || __len2 == 0)
+    return;
+  if (__len1 + __len2 == 2) {
+    if (__comp(*__middle, *__first))
+      iter_swap(__first, __middle);
+    return;
+  }
+  _BidirectionalIter __first_cut = __first;
+  _BidirectionalIter __second_cut = __middle;
+  _Distance __len11 = 0;
+  _Distance __len22 = 0;
+  if (__len1 > __len2) {
+    __len11 = __len1 / 2;
+    advance(__first_cut, __len11);
+    __second_cut = lower_bound(__middle, __last, *__first_cut, __comp);
+    distance(__middle, __second_cut, __len22);
+  }
+  else {
+    __len22 = __len2 / 2;
+    advance(__second_cut, __len22);
+    __first_cut = upper_bound(__first, __middle, *__second_cut, __comp);
+    distance(__first, __first_cut, __len11);
+  }
+  _BidirectionalIter __new_middle
+    = rotate(__first_cut, __middle, __second_cut);
+  __merge_without_buffer(__first, __first_cut, __new_middle, __len11, __len22,
+                         __comp);
+  __merge_without_buffer(__new_middle, __second_cut, __last, __len1 - __len11,
+                         __len2 - __len22, __comp);
+}
+
+template <class _BidirectionalIter1, class _BidirectionalIter2,
+          class _Distance>
+_BidirectionalIter1 __rotate_adaptive(_BidirectionalIter1 __first,
+                                      _BidirectionalIter1 __middle,
+                                      _BidirectionalIter1 __last,
+                                      _Distance __len1, _Distance __len2,
+                                      _BidirectionalIter2 __buffer,
+                                      _Distance __buffer_size) {
+  _BidirectionalIter2 __buffer_end;
+  if (__len1 > __len2 && __len2 <= __buffer_size) {
+    __buffer_end = copy(__middle, __last, __buffer);
+    copy_backward(__first, __middle, __last);
+    return copy(__buffer, __buffer_end, __first);
+  }
+  else if (__len1 <= __buffer_size) {
+    __buffer_end = copy(__first, __middle, __buffer);
+    copy(__middle, __last, __first);
+    return copy_backward(__buffer, __buffer_end, __last);
+  }
+  else
+    return rotate(__first, __middle, __last);
+}
+
+template <class _BidirectionalIter1, class _BidirectionalIter2,
+          class _BidirectionalIter3>
+_BidirectionalIter3 __merge_backward(_BidirectionalIter1 __first1,
+                                     _BidirectionalIter1 __last1,
+                                     _BidirectionalIter2 __first2,
+                                     _BidirectionalIter2 __last2,
+                                     _BidirectionalIter3 __result) {
+  if (__first1 == __last1)
+    return copy_backward(__first2, __last2, __result);
+  if (__first2 == __last2)
+    return copy_backward(__first1, __last1, __result);
+  --__last1;
+  --__last2;
+  while (true) {
+    if (*__last2 < *__last1) {
+      *--__result = *__last1;
+      if (__first1 == __last1)
+        return copy_backward(__first2, ++__last2, __result);
+      --__last1;
+    }
+    else {
+      *--__result = *__last2;
+      if (__first2 == __last2)
+        return copy_backward(__first1, ++__last1, __result);
+      --__last2;
+    }
+  }
+}
+
+template <class _BidirectionalIter1, class _BidirectionalIter2,
+          class _BidirectionalIter3, class _Compare>
+_BidirectionalIter3 __merge_backward(_BidirectionalIter1 __first1,
+                                     _BidirectionalIter1 __last1,
+                                     _BidirectionalIter2 __first2,
+                                     _BidirectionalIter2 __last2,
+                                     _BidirectionalIter3 __result,
+                                     _Compare __comp) {
+  if (__first1 == __last1)
+    return copy_backward(__first2, __last2, __result);
+  if (__first2 == __last2)
+    return copy_backward(__first1, __last1, __result);
+  --__last1;
+  --__last2;
+  while (true) {
+    if (__comp(*__last2, *__last1)) {
+      *--__result = *__last1;
+      if (__first1 == __last1)
+        return copy_backward(__first2, ++__last2, __result);
+      --__last1;
+    }
+    else {
+      *--__result = *__last2;
+      if (__first2 == __last2)
+        return copy_backward(__first1, ++__last1, __result);
+      --__last2;
+    }
+  }
+}
+
+template <class _BidirectionalIter, class _Distance, class _Pointer>
+void __merge_adaptive(_BidirectionalIter __first,
+                      _BidirectionalIter __middle, 
+                      _BidirectionalIter __last,
+                      _Distance __len1, _Distance __len2,
+                      _Pointer __buffer, _Distance __buffer_size) {
+  if (__len1 <= __len2 && __len1 <= __buffer_size) {
+    _Pointer __buffer_end = copy(__first, __middle, __buffer);
+    merge(__buffer, __buffer_end, __middle, __last, __first);
+  }
+  else if (__len2 <= __buffer_size) {
+    _Pointer __buffer_end = copy(__middle, __last, __buffer);
+    __merge_backward(__first, __middle, __buffer, __buffer_end, __last);
+  }
+  else {
+    _BidirectionalIter __first_cut = __first;
+    _BidirectionalIter __second_cut = __middle;
+    _Distance __len11 = 0;
+    _Distance __len22 = 0;
+    if (__len1 > __len2) {
+      __len11 = __len1 / 2;
+      advance(__first_cut, __len11);
+      __second_cut = lower_bound(__middle, __last, *__first_cut);
+      distance(__middle, __second_cut, __len22); 
+    }
+    else {
+      __len22 = __len2 / 2;
+      advance(__second_cut, __len22);
+      __first_cut = upper_bound(__first, __middle, *__second_cut);
+      distance(__first, __first_cut, __len11);
+    }
+    _BidirectionalIter __new_middle =
+      __rotate_adaptive(__first_cut, __middle, __second_cut, __len1 - __len11,
+                        __len22, __buffer, __buffer_size);
+    __merge_adaptive(__first, __first_cut, __new_middle, __len11,
+                     __len22, __buffer, __buffer_size);
+    __merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11,
+                     __len2 - __len22, __buffer, __buffer_size);
+  }
+}
+
+template <class _BidirectionalIter, class _Distance, class _Pointer,
+          class _Compare>
+void __merge_adaptive(_BidirectionalIter __first, 
+                      _BidirectionalIter __middle, 
+                      _BidirectionalIter __last,
+                      _Distance __len1, _Distance __len2,
+                      _Pointer __buffer, _Distance __buffer_size,
+                      _Compare __comp) {
+  if (__len1 <= __len2 && __len1 <= __buffer_size) {
+    _Pointer __buffer_end = copy(__first, __middle, __buffer);
+    merge(__buffer, __buffer_end, __middle, __last, __first, __comp);
+  }
+  else if (__len2 <= __buffer_size) {
+    _Pointer __buffer_end = copy(__middle, __last, __buffer);
+    __merge_backward(__first, __middle, __buffer, __buffer_end, __last,
+                     __comp);
+  }
+  else {
+    _BidirectionalIter __first_cut = __first;
+    _BidirectionalIter __second_cut = __middle;
+    _Distance __len11 = 0;
+    _Distance __len22 = 0;
+    if (__len1 > __len2) {
+      __len11 = __len1 / 2;
+      advance(__first_cut, __len11);
+      __second_cut = lower_bound(__middle, __last, *__first_cut, __comp);
+      distance(__middle, __second_cut, __len22);   
+    }
+    else {
+      __len22 = __len2 / 2;
+      advance(__second_cut, __len22);
+      __first_cut = upper_bound(__first, __middle, *__second_cut, __comp);
+      distance(__first, __first_cut, __len11);
+    }
+    _BidirectionalIter __new_middle =
+      __rotate_adaptive(__first_cut, __middle, __second_cut, __len1 - __len11,
+                        __len22, __buffer, __buffer_size);
+    __merge_adaptive(__first, __first_cut, __new_middle, __len11,
+                     __len22, __buffer, __buffer_size, __comp);
+    __merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11,
+                     __len2 - __len22, __buffer, __buffer_size, __comp);
+  }
+}
+
+template <class _BidirectionalIter, class _Tp, class _Distance>
+inline void __inplace_merge_aux(_BidirectionalIter __first,
+                                _BidirectionalIter __middle,
+                                _BidirectionalIter __last, _Tp*, _Distance*) {
+  _Distance __len1 = 0;
+  distance(__first, __middle, __len1);
+  _Distance __len2 = 0;
+  distance(__middle, __last, __len2);
+
+  _Temporary_buffer<_BidirectionalIter, _Tp> __buf(__first, __last);
+  if (__buf.begin() == 0)
+    __merge_without_buffer(__first, __middle, __last, __len1, __len2);
+  else
+    __merge_adaptive(__first, __middle, __last, __len1, __len2,
+                     __buf.begin(), _Distance(__buf.size()));
+}
+
+template <class _BidirectionalIter, class _Tp, 
+          class _Distance, class _Compare>
+inline void __inplace_merge_aux(_BidirectionalIter __first,
+                                _BidirectionalIter __middle,
+                                _BidirectionalIter __last, _Tp*, _Distance*,
+                                _Compare __comp) {
+  _Distance __len1 = 0;
+  distance(__first, __middle, __len1);
+  _Distance __len2 = 0;
+  distance(__middle, __last, __len2);
+
+  _Temporary_buffer<_BidirectionalIter, _Tp> __buf(__first, __last);
+  if (__buf.begin() == 0)
+    __merge_without_buffer(__first, __middle, __last, __len1, __len2, __comp);
+  else
+    __merge_adaptive(__first, __middle, __last, __len1, __len2,
+                     __buf.begin(), _Distance(__buf.size()),
+                     __comp);
+}
+
+template <class _BidirectionalIter>
+inline void inplace_merge(_BidirectionalIter __first,
+                          _BidirectionalIter __middle,
+                          _BidirectionalIter __last) {
+  if (__first == __middle || __middle == __last)
+    return;
+  __inplace_merge_aux(__first, __middle, __last,
+                      __VALUE_TYPE(__first), __DISTANCE_TYPE(__first));
+}
+
+template <class _BidirectionalIter, class _Compare>
+inline void inplace_merge(_BidirectionalIter __first,
+                          _BidirectionalIter __middle,
+                          _BidirectionalIter __last, _Compare __comp) {
+  if (__first == __middle || __middle == __last)
+    return;
+  __inplace_merge_aux(__first, __middle, __last,
+                      __VALUE_TYPE(__first), __DISTANCE_TYPE(__first),
+                      __comp);
+}
+
+// Set algorithms: includes, set_union, set_intersection, set_difference,
+// set_symmetric_difference.  All of these algorithms have the precondition
+// that their input ranges are sorted and the postcondition that their output
+// ranges are sorted.
+
+template <class _InputIter1, class _InputIter2>
+bool includes(_InputIter1 __first1, _InputIter1 __last1,
+              _InputIter2 __first2, _InputIter2 __last2) {
+  while (__first1 != __last1 && __first2 != __last2)
+    if (*__first2 < *__first1)
+      return false;
+    else if(*__first1 < *__first2) 
+      ++__first1;
+    else
+      ++__first1, ++__first2;
+
+  return __first2 == __last2;
+}
+
+template <class _InputIter1, class _InputIter2, class _Compare>
+bool includes(_InputIter1 __first1, _InputIter1 __last1,
+              _InputIter2 __first2, _InputIter2 __last2, _Compare __comp) {
+  while (__first1 != __last1 && __first2 != __last2)
+    if (__comp(*__first2, *__first1))
+      return false;
+    else if(__comp(*__first1, *__first2)) 
+      ++__first1;
+    else
+      ++__first1, ++__first2;
+
+  return __first2 == __last2;
+}
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
+                      _InputIter2 __first2, _InputIter2 __last2,
+                      _OutputIter __result) {
+  while (__first1 != __last1 && __first2 != __last2) {
+    if (*__first1 < *__first2) {
+      *__result = *__first1;
+      ++__first1;
+    }
+    else if (*__first2 < *__first1) {
+      *__result = *__first2;
+      ++__first2;
+    }
+    else {
+      *__result = *__first1;
+      ++__first1;
+      ++__first2;
+    }
+    ++__result;
+  }
+  return copy(__first2, __last2, copy(__first1, __last1, __result));
+}
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+          class _Compare>
+_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
+                      _InputIter2 __first2, _InputIter2 __last2,
+                      _OutputIter __result, _Compare __comp) {
+  while (__first1 != __last1 && __first2 != __last2) {
+    if (__comp(*__first1, *__first2)) {
+      *__result = *__first1;
+      ++__first1;
+    }
+    else if (__comp(*__first2, *__first1)) {
+      *__result = *__first2;
+      ++__first2;
+    }
+    else {
+      *__result = *__first1;
+      ++__first1;
+      ++__first2;
+    }
+    ++__result;
+  }
+  return copy(__first2, __last2, copy(__first1, __last1, __result));
+}
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
+                             _InputIter2 __first2, _InputIter2 __last2,
+                             _OutputIter __result) {
+  while (__first1 != __last1 && __first2 != __last2) 
+    if (*__first1 < *__first2) 
+      ++__first1;
+    else if (*__first2 < *__first1) 
+      ++__first2;
+    else {
+      *__result = *__first1;
+      ++__first1;
+      ++__first2;
+      ++__result;
+    }
+  return __result;
+}
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+          class _Compare>
+_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
+                             _InputIter2 __first2, _InputIter2 __last2,
+                             _OutputIter __result, _Compare __comp) {
+  while (__first1 != __last1 && __first2 != __last2)
+    if (__comp(*__first1, *__first2))
+      ++__first1;
+    else if (__comp(*__first2, *__first1))
+      ++__first2;
+    else {
+      *__result = *__first1;
+      ++__first1;
+      ++__first2;
+      ++__result;
+    }
+  return __result;
+}
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
+                           _InputIter2 __first2, _InputIter2 __last2,
+                           _OutputIter __result) {
+  while (__first1 != __last1 && __first2 != __last2)
+    if (*__first1 < *__first2) {
+      *__result = *__first1;
+      ++__first1;
+      ++__result;
+    }
+    else if (*__first2 < *__first1)
+      ++__first2;
+    else {
+      ++__first1;
+      ++__first2;
+    }
+  return copy(__first1, __last1, __result);
+}
+
+template <class _InputIter1, class _InputIter2, class _OutputIter, 
+          class _Compare>
+_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
+                           _InputIter2 __first2, _InputIter2 __last2, 
+                           _OutputIter __result, _Compare __comp) {
+  while (__first1 != __last1 && __first2 != __last2)
+    if (__comp(*__first1, *__first2)) {
+      *__result = *__first1;
+      ++__first1;
+      ++__result;
+    }
+    else if (__comp(*__first2, *__first1))
+      ++__first2;
+    else {
+      ++__first1;
+      ++__first2;
+    }
+  return copy(__first1, __last1, __result);
+}
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter 
+set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
+                         _InputIter2 __first2, _InputIter2 __last2,
+                         _OutputIter __result) {
+  while (__first1 != __last1 && __first2 != __last2)
+    if (*__first1 < *__first2) {
+      *__result = *__first1;
+      ++__first1;
+      ++__result;
+    }
+    else if (*__first2 < *__first1) {
+      *__result = *__first2;
+      ++__first2;
+      ++__result;
+    }
+    else {
+      ++__first1;
+      ++__first2;
+    }
+  return copy(__first2, __last2, copy(__first1, __last1, __result));
+}
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+          class _Compare>
+_OutputIter 
+set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
+                         _InputIter2 __first2, _InputIter2 __last2,
+                         _OutputIter __result,
+                         _Compare __comp) {
+  while (__first1 != __last1 && __first2 != __last2)
+    if (__comp(*__first1, *__first2)) {
+      *__result = *__first1;
+      ++__first1;
+      ++__result;
+    }
+    else if (__comp(*__first2, *__first1)) {
+      *__result = *__first2;
+      ++__first2;
+      ++__result;
+    }
+    else {
+      ++__first1;
+      ++__first2;
+    }
+  return copy(__first2, __last2, copy(__first1, __last1, __result));
+}
+
+// min_element and max_element, with and without an explicitly supplied
+// comparison function.
+
+template <class _ForwardIter>
+_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last) {
+  if (__first == __last) return __first;
+  _ForwardIter __result = __first;
+  while (++__first != __last) 
+    if (*__result < *__first)
+      __result = __first;
+  return __result;
+}
+
+template <class _ForwardIter, class _Compare>
+_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last,
+                            _Compare __comp) {
+  if (__first == __last) return __first;
+  _ForwardIter __result = __first;
+  while (++__first != __last) 
+    if (__comp(*__result, *__first)) __result = __first;
+  return __result;
+}
+
+template <class _ForwardIter>
+_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last) {
+  if (__first == __last) return __first;
+  _ForwardIter __result = __first;
+  while (++__first != __last) 
+    if (*__first < *__result)
+      __result = __first;
+  return __result;
+}
+
+template <class _ForwardIter, class _Compare>
+_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last,
+                            _Compare __comp) {
+  if (__first == __last) return __first;
+  _ForwardIter __result = __first;
+  while (++__first != __last) 
+    if (__comp(*__first, *__result))
+      __result = __first;
+  return __result;
+}
+
+// next_permutation and prev_permutation, with and without an explicitly 
+// supplied comparison function.
+
+template <class _BidirectionalIter>
+bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last) {
+  if (__first == __last)
+    return false;
+  _BidirectionalIter __i = __first;
+  ++__i;
+  if (__i == __last)
+    return false;
+  __i = __last;
+  --__i;
+
+  for(;;) {
+    _BidirectionalIter __ii = __i;
+    --__i;
+    if (*__i < *__ii) {
+      _BidirectionalIter __j = __last;
+      while (!(*__i < *--__j))
+        {}
+      iter_swap(__i, __j);
+      reverse(__ii, __last);
+      return true;
+    }
+    if (__i == __first) {
+      reverse(__first, __last);
+      return false;
+    }
+  }
+}
+
+template <class _BidirectionalIter, class _Compare>
+bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
+                      _Compare __comp) {
+  if (__first == __last)
+    return false;
+  _BidirectionalIter __i = __first;
+  ++__i;
+  if (__i == __last)
+    return false;
+  __i = __last;
+  --__i;
+
+  for(;;) {
+    _BidirectionalIter __ii = __i;
+    --__i;
+    if (__comp(*__i, *__ii)) {
+      _BidirectionalIter __j = __last;
+      while (!__comp(*__i, *--__j))
+        {}
+      iter_swap(__i, __j);
+      reverse(__ii, __last);
+      return true;
+    }
+    if (__i == __first) {
+      reverse(__first, __last);
+      return false;
+    }
+  }
+}
+
+template <class _BidirectionalIter>
+bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last) {
+  if (__first == __last)
+    return false;
+  _BidirectionalIter __i = __first;
+  ++__i;
+  if (__i == __last)
+    return false;
+  __i = __last;
+  --__i;
+
+  for(;;) {
+    _BidirectionalIter __ii = __i;
+    --__i;
+    if (*__ii < *__i) {
+      _BidirectionalIter __j = __last;
+      while (!(*--__j < *__i))
+        {}
+      iter_swap(__i, __j);
+      reverse(__ii, __last);
+      return true;
+    }
+    if (__i == __first) {
+      reverse(__first, __last);
+      return false;
+    }
+  }
+}
+
+template <class _BidirectionalIter, class _Compare>
+bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
+                      _Compare __comp) {
+  if (__first == __last)
+    return false;
+  _BidirectionalIter __i = __first;
+  ++__i;
+  if (__i == __last)
+    return false;
+  __i = __last;
+  --__i;
+
+  for(;;) {
+    _BidirectionalIter __ii = __i;
+    --__i;
+    if (__comp(*__ii, *__i)) {
+      _BidirectionalIter __j = __last;
+      while (!__comp(*--__j, *__i))
+        {}
+      iter_swap(__i, __j);
+      reverse(__ii, __last);
+      return true;
+    }
+    if (__i == __first) {
+      reverse(__first, __last);
+      return false;
+    }
+  }
+}
+
+// find_first_of, with and without an explicitly supplied comparison function.
+
+template <class _InputIter, class _ForwardIter>
+_InputIter find_first_of(_InputIter __first1, _InputIter __last1,
+                         _ForwardIter __first2, _ForwardIter __last2)
+{
+  for ( ; __first1 != __last1; ++__first1) 
+    for (_ForwardIter __iter = __first2; __iter != __last2; ++__iter)
+      if (*__first1 == *__iter)
+        return __first1;
+  return __last1;
+}
+
+template <class _InputIter, class _ForwardIter, class _BinaryPredicate>
+_InputIter find_first_of(_InputIter __first1, _InputIter __last1,
+                         _ForwardIter __first2, _ForwardIter __last2,
+                         _BinaryPredicate __comp)
+{
+  for ( ; __first1 != __last1; ++__first1) 
+    for (_ForwardIter __iter = __first2; __iter != __last2; ++__iter)
+      if (__comp(*__first1, *__iter))
+        return __first1;
+  return __last1;
+}
+
+
+// find_end, with and without an explicitly supplied comparison function.
+// Search [first2, last2) as a subsequence in [first1, last1), and return
+// the *last* possible match.  Note that find_end for bidirectional iterators
+// is much faster than for forward iterators.
+
+// find_end for forward iterators. 
+template <class _ForwardIter1, class _ForwardIter2>
+_ForwardIter1 __find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
+                         _ForwardIter2 __first2, _ForwardIter2 __last2,
+                         forward_iterator_tag, forward_iterator_tag)
+{
+  if (__first2 == __last2)
+    return __last1;
+  else {
+    _ForwardIter1 __result = __last1;
+    while (1) {
+      _ForwardIter1 __new_result
+        = search(__first1, __last1, __first2, __last2);
+      if (__new_result == __last1)
+        return __result;
+      else {
+        __result = __new_result;
+        __first1 = __new_result;
+        ++__first1;
+      }
+    }
+  }
+}
+
+template <class _ForwardIter1, class _ForwardIter2,
+          class _BinaryPredicate>
+_ForwardIter1 __find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
+                         _ForwardIter2 __first2, _ForwardIter2 __last2,
+                         forward_iterator_tag, forward_iterator_tag,
+                         _BinaryPredicate __comp)
+{
+  if (__first2 == __last2)
+    return __last1;
+  else {
+    _ForwardIter1 __result = __last1;
+    while (1) {
+      _ForwardIter1 __new_result
+        = search(__first1, __last1, __first2, __last2, __comp);
+      if (__new_result == __last1)
+        return __result;
+      else {
+        __result = __new_result;
+        __first1 = __new_result;
+        ++__first1;
+      }
+    }
+  }
+}
+
+// find_end for bidirectional iterators.  Requires partial specialization.
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class _BidirectionalIter1, class _BidirectionalIter2>
+_BidirectionalIter1
+__find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
+           _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
+           bidirectional_iterator_tag, bidirectional_iterator_tag)
+{
+  typedef reverse_iterator<_BidirectionalIter1> _RevIter1;
+  typedef reverse_iterator<_BidirectionalIter2> _RevIter2;
+
+  _RevIter1 __rlast1(__first1);
+  _RevIter2 __rlast2(__first2);
+  _RevIter1 __rresult = search(_RevIter1(__last1), __rlast1,
+                               _RevIter2(__last2), __rlast2);
+
+  if (__rresult == __rlast1)
+    return __last1;
+  else {
+    _BidirectionalIter1 __result = __rresult.base();
+    advance(__result, -distance(__first2, __last2));
+    return __result;
+  }
+}
+
+template <class _BidirectionalIter1, class _BidirectionalIter2,
+          class _BinaryPredicate>
+_BidirectionalIter1
+__find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
+           _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
+           bidirectional_iterator_tag, bidirectional_iterator_tag, 
+           _BinaryPredicate __comp)
+{
+  typedef reverse_iterator<_BidirectionalIter1> _RevIter1;
+  typedef reverse_iterator<_BidirectionalIter2> _RevIter2;
+
+  _RevIter1 __rlast1(__first1);
+  _RevIter2 __rlast2(__first2);
+  _RevIter1 __rresult = search(_RevIter1(__last1), __rlast1,
+                               _RevIter2(__last2), __rlast2,
+                               __comp);
+
+  if (__rresult == __rlast1)
+    return __last1;
+  else {
+    _BidirectionalIter1 __result = __rresult.base();
+    advance(__result, -distance(__first2, __last2));
+    return __result;
+  }
+}
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+// Dispatching functions for find_end.
+
+template <class _ForwardIter1, class _ForwardIter2>
+inline _ForwardIter1 
+find_end(_ForwardIter1 __first1, _ForwardIter1 __last1, 
+         _ForwardIter2 __first2, _ForwardIter2 __last2)
+{
+  return __find_end(__first1, __last1, __first2, __last2,
+                    __ITERATOR_CATEGORY(__first1),
+                    __ITERATOR_CATEGORY(__first2));
+}
+
+template <class _ForwardIter1, class _ForwardIter2, 
+          class _BinaryPredicate>
+inline _ForwardIter1 
+find_end(_ForwardIter1 __first1, _ForwardIter1 __last1, 
+         _ForwardIter2 __first2, _ForwardIter2 __last2,
+         _BinaryPredicate __comp)
+{
+  return __find_end(__first1, __last1, __first2, __last2,
+                    __ITERATOR_CATEGORY(__first1),
+                    __ITERATOR_CATEGORY(__first2),
+                    __comp);
+}
+
+// is_heap, a predicate testing whether or not a range is
+// a heap.  This function is an extension, not part of the C++
+// standard.
+
+template <class _RandomAccessIter, class _Distance>
+bool __is_heap(_RandomAccessIter __first, _Distance __n)
+{
+  _Distance __parent = 0;
+  for (_Distance __child = 1; __child < __n; ++__child) {
+    if (__first[__parent] < __first[__child]) 
+      return false;
+    if ((__child & 1) == 0)
+      ++__parent;
+  }
+  return true;
+}
+
+template <class _RandomAccessIter, class _Distance, class _StrictWeakOrdering>
+bool __is_heap(_RandomAccessIter __first, _StrictWeakOrdering __comp,
+               _Distance __n)
+{
+  _Distance __parent = 0;
+  for (_Distance __child = 1; __child < __n; ++__child) {
+    if (__comp(__first[__parent], __first[__child]))
+      return false;
+    if ((__child & 1) == 0)
+      ++__parent;
+  }
+  return true;
+}
+
+template <class _RandomAccessIter>
+inline bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last)
+{
+  return __is_heap(__first, __last - __first);
+}
+
+
+template <class _RandomAccessIter, class _StrictWeakOrdering>
+inline bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last,
+                    _StrictWeakOrdering __comp)
+{
+  return __is_heap(__first, __comp, __last - __first);
+}
+
+// is_sorted, a predicated testing whether a range is sorted in
+// nondescending order.  This is an extension, not part of the C++
+// standard.
+
+template <class _ForwardIter>
+bool is_sorted(_ForwardIter __first, _ForwardIter __last)
+{
+  if (__first == __last)
+    return true;
+
+  _ForwardIter __next = __first;
+  for (++__next; __next != __last; __first = __next, ++__next) {
+    if (*__next < *__first)
+      return false;
+  }
+
+  return true;
+}
+
+template <class _ForwardIter, class _StrictWeakOrdering>
+bool is_sorted(_ForwardIter __first, _ForwardIter __last,
+               _StrictWeakOrdering __comp)
+{
+  if (__first == __last)
+    return true;
+
+  _ForwardIter __next = __first;
+  for (++__next; __next != __last; __first = __next, ++__next) {
+    if (__comp(*__next, *__first))
+      return false;
+  }
+
+  return true;
+}
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1209
+#endif
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_ALGO_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_algobase.h b/gnu/egcs/libstdc++/stl/stl_algobase.h
new file mode 100644
index 00000000000..15e535f483d
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_algobase.h
@@ -0,0 +1,526 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+
+#ifndef __SGI_STL_INTERNAL_ALGOBASE_H
+#define __SGI_STL_INTERNAL_ALGOBASE_H
+
+#ifndef __STL_CONFIG_H
+#include <stl_config.h>
+#endif
+#ifndef __SGI_STL_INTERNAL_RELOPS
+#include <stl_relops.h>
+#endif
+#ifndef __SGI_STL_INTERNAL_PAIR_H
+#include <stl_pair.h>
+#endif
+#ifndef __TYPE_TRAITS_H_
+#include <type_traits.h>
+#endif
+
+#include <string.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <new.h>
+#include <iostream.h>
+
+#ifndef __SGI_STL_INTERNAL_ITERATOR_H
+#include <stl_iterator.h>
+#endif
+
+__STL_BEGIN_NAMESPACE
+
+// swap and iter_swap
+
+template <class _ForwardIter1, class _ForwardIter2, class _Tp>
+inline void __iter_swap(_ForwardIter1 __a, _ForwardIter2 __b, _Tp*) {
+  _Tp __tmp = *__a;
+  *__a = *__b;
+  *__b = __tmp;
+}
+
+template <class _ForwardIter1, class _ForwardIter2>
+inline void iter_swap(_ForwardIter1 __a, _ForwardIter2 __b) {
+  __iter_swap(__a, __b, __VALUE_TYPE(__a));
+}
+
+template <class _Tp>
+inline void swap(_Tp& __a, _Tp& __b) {
+  _Tp __tmp = __a;
+  __a = __b;
+  __b = __tmp;
+}
+
+//--------------------------------------------------
+// min and max
+
+#ifndef __BORLANDC__
+
+#undef min
+#undef max
+
+template <class _Tp>
+inline const _Tp& min(const _Tp& __a, const _Tp& __b) {
+  return __b < __a ? __b : __a;
+}
+
+template <class _Tp>
+inline const _Tp& max(const _Tp& __a, const _Tp& __b) {
+  return  __a < __b ? __b : __a;
+}
+
+#endif /* __BORLANDC__ */
+
+template <class _Tp, class _Compare>
+inline const _Tp& min(const _Tp& __a, const _Tp& __b, _Compare __comp) {
+  return __comp(__b, __a) ? __b : __a;
+}
+
+template <class _Tp, class _Compare>
+inline const _Tp& max(const _Tp& __a, const _Tp& __b, _Compare __comp) {
+  return __comp(__a, __b) ? __b : __a;
+}
+
+//--------------------------------------------------
+// copy
+
+// All of these auxiliary functions serve two purposes.  (1) Replace
+// calls to copy with memmove whenever possible.  (Memmove, not memcpy,
+// because the input and output ranges are permitted to overlap.)
+// (2) If we're using random access iterators, then write the loop as
+// a for loop with an explicit count.  The auxiliary class __copy_dispatch
+// is a workaround for compilers that don't support partial ordering of
+// function templates.
+
+template <class _InputIter, class _OutputIter, class _Distance>
+inline _OutputIter __copy(_InputIter __first, _InputIter __last,
+                          _OutputIter __result,
+                          input_iterator_tag, _Distance*)
+{
+  for ( ; __first != __last; ++__result, ++__first)
+    *__result = *__first;
+  return __result;
+}
+
+template <class _RandomAccessIter, class _OutputIter, class _Distance>
+inline _OutputIter
+__copy(_RandomAccessIter __first, _RandomAccessIter __last,
+       _OutputIter __result, random_access_iterator_tag, _Distance*)
+{
+  for (_Distance __n = __last - __first; __n > 0; --__n) {
+    *__result = *__first;
+    ++__first;
+    ++__result;
+  }
+  return __result;
+}
+
+template <class _Tp>
+inline _Tp*
+__copy_trivial(const _Tp* __first, const _Tp* __last, _Tp* __result) {
+  memmove(__result, __first, sizeof(_Tp) * (__last - __first));
+  return __result + (__last - __first);
+}
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION 
+
+template <class _InputIter, class _OutputIter, class _BoolType>
+struct __copy_dispatch {
+  static _OutputIter copy(_InputIter __first, _InputIter __last,
+                          _OutputIter __result) {
+    typedef typename iterator_traits<_InputIter>::iterator_category _Category;
+    typedef typename iterator_traits<_InputIter>::difference_type _Distance;
+    return __copy(__first, __last, __result, _Category(), (_Distance*) 0);
+  }
+};
+
+template <class _Tp>
+struct __copy_dispatch<_Tp*, _Tp*, __true_type>
+{
+  static _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) {
+    return __copy_trivial(__first, __last, __result);
+  }
+};
+
+template <class _Tp>
+struct __copy_dispatch<const _Tp*, _Tp*, __true_type>
+{
+  static _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) {
+    return __copy_trivial(__first, __last, __result);
+  }
+};
+
+template <class _InputIter, class _OutputIter>
+inline _OutputIter copy(_InputIter __first, _InputIter __last,
+                        _OutputIter __result) {
+  typedef typename iterator_traits<_InputIter>::value_type _Tp;
+  typedef typename __type_traits<_Tp>::has_trivial_assignment_operator
+          _Trivial;
+  return __copy_dispatch<_InputIter, _OutputIter, _Trivial>
+    ::copy(__first, __last, __result);
+}
+
+#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+template <class _InputIter, class _OutputIter>
+inline _OutputIter copy(_InputIter __first, _InputIter __last,
+                        _OutputIter __result)
+{
+  return __copy(__first, __last, __result,
+                __ITERATOR_CATEGORY(__first),
+                __DISTANCE_TYPE(__first));
+}
+
+inline char* copy(const char* __first, const char* __last, char* __result) {
+  memmove(__result, __first, __last - __first);
+  return __result + (__last - __first);
+}
+
+inline wchar_t* copy(const wchar_t* __first, const wchar_t* __last,
+                     wchar_t* __result) {
+  memmove(__result, __first, sizeof(wchar_t) * (__last - __first));
+  return __result + (__last - __first);
+}
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+//--------------------------------------------------
+// copy_backward
+
+template <class _BidirectionalIter1, class _BidirectionalIter2, 
+          class _Distance>
+inline _BidirectionalIter2 __copy_backward(_BidirectionalIter1 __first, 
+                                           _BidirectionalIter1 __last, 
+                                           _BidirectionalIter2 __result,
+                                           bidirectional_iterator_tag,
+                                           _Distance*)
+{
+  while (__first != __last)
+    *--__result = *--__last;
+  return __result;
+}
+
+template <class _RandomAccessIter, class _BidirectionalIter, class _Distance>
+inline _BidirectionalIter __copy_backward(_RandomAccessIter __first, 
+                                          _RandomAccessIter __last, 
+                                          _BidirectionalIter __result,
+                                          random_access_iterator_tag,
+                                          _Distance*)
+{
+  for (_Distance __n = __last - __first; __n > 0; --__n)
+    *--__result = *--__last;
+  return __result;
+}
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION 
+
+// This dispatch class is a workaround for compilers that do not 
+// have partial ordering of function templates.  All we're doing is
+// creating a specialization so that we can turn a call to copy_backward
+// into a memmove whenever possible.
+
+template <class _BidirectionalIter1, class _BidirectionalIter2,
+          class _BoolType>
+struct __copy_backward_dispatch
+{
+  typedef typename iterator_traits<_BidirectionalIter1>::iterator_category 
+          _Cat;
+  typedef typename iterator_traits<_BidirectionalIter1>::difference_type
+          _Distance;
+
+  static _BidirectionalIter2 copy(_BidirectionalIter1 __first, 
+                                  _BidirectionalIter1 __last, 
+                                  _BidirectionalIter2 __result) {
+    return __copy_backward(__first, __last, __result, _Cat(), (_Distance*) 0);
+  }
+};
+
+template <class _Tp>
+struct __copy_backward_dispatch<_Tp*, _Tp*, __true_type>
+{
+  static _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) {
+    const ptrdiff_t _Num = __last - __first;
+    memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
+    return __result - _Num;
+  }
+};
+
+template <class _Tp>
+struct __copy_backward_dispatch<const _Tp*, _Tp*, __true_type>
+{
+  static _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) {
+    return  __copy_backward_dispatch<_Tp*, _Tp*, __true_type>
+      ::copy(__first, __last, __result);
+  }
+};
+
+template <class _BI1, class _BI2>
+inline _BI2 copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) {
+  typedef typename __type_traits<typename iterator_traits<_BI2>::value_type>
+                        ::has_trivial_assignment_operator
+          _Trivial;
+  return __copy_backward_dispatch<_BI1, _BI2, _Trivial>
+              ::copy(__first, __last, __result);
+}
+
+#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+template <class _BI1, class _BI2>
+inline _BI2 copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) {
+  return __copy_backward(__first, __last, __result,
+                         __ITERATOR_CATEGORY(__first),
+                         __DISTANCE_TYPE(__first));
+}
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+//--------------------------------------------------
+// copy_n (not part of the C++ standard)
+
+template <class _InputIter, class _Size, class _OutputIter>
+pair<_InputIter, _OutputIter> __copy_n(_InputIter __first, _Size __count,
+                                       _OutputIter __result,
+                                       input_iterator_tag) {
+  for ( ; __count > 0; --__count) {
+    *__result = *__first;
+    ++__first;
+    ++__result;
+  }
+  return pair<_InputIter, _OutputIter>(__first, __result);
+}
+
+template <class _RAIter, class _Size, class _OutputIter>
+inline pair<_RAIter, _OutputIter>
+__copy_n(_RAIter __first, _Size __count,
+         _OutputIter __result,
+         random_access_iterator_tag) {
+  _RAIter __last = __first + __count;
+  return pair<_RAIter, _OutputIter>(__last, copy(__first, __last, __result));
+}
+
+template <class _InputIter, class _Size, class _OutputIter>
+inline pair<_InputIter, _OutputIter>
+__copy_n(_InputIter __first, _Size __count, _OutputIter __result) {
+  return __copy_n(__first, __count, __result,
+                  __ITERATOR_CATEGORY(__first));
+}
+
+template <class _InputIter, class _Size, class _OutputIter>
+inline pair<_InputIter, _OutputIter>
+copy_n(_InputIter __first, _Size __count, _OutputIter __result) {
+  return __copy_n(__first, __count, __result);
+}
+
+//--------------------------------------------------
+// fill and fill_n
+
+
+template <class _ForwardIter, class _Tp>
+void fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __value) {
+  for ( ; __first != __last; ++__first)
+    *__first = __value;
+}
+
+template <class _OutputIter, class _Size, class _Tp>
+_OutputIter fill_n(_OutputIter __first, _Size __n, const _Tp& __value) {
+  for ( ; __n > 0; --__n, ++__first)
+    *__first = __value;
+  return __first;
+}
+
+//--------------------------------------------------
+// equal and mismatch
+
+template <class _InputIter1, class _InputIter2>
+pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1,
+                                        _InputIter1 __last1,
+                                        _InputIter2 __first2) {
+  while (__first1 != __last1 && *__first1 == *__first2) {
+    ++__first1;
+    ++__first2;
+  }
+  return pair<_InputIter1, _InputIter2>(__first1, __first2);
+}
+
+template <class _InputIter1, class _InputIter2, class _BinaryPredicate>
+pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1,
+                                        _InputIter1 __last1,
+                                        _InputIter2 __first2,
+                                        _BinaryPredicate __binary_pred) {
+  while (__first1 != __last1 && __binary_pred(*__first1, *__first2)) {
+    ++__first1;
+    ++__first2;
+  }
+  return pair<_InputIter1, _InputIter2>(__first1, __first2);
+}
+
+template <class _InputIter1, class _InputIter2>
+inline bool equal(_InputIter1 __first1, _InputIter1 __last1,
+                  _InputIter2 __first2) {
+  for ( ; __first1 != __last1; ++__first1, ++__first2)
+    if (*__first1 != *__first2)
+      return false;
+  return true;
+}
+
+template <class _InputIter1, class _InputIter2, class _BinaryPredicate>
+inline bool equal(_InputIter1 __first1, _InputIter1 __last1,
+                  _InputIter2 __first2, _BinaryPredicate __binary_pred) {
+  for ( ; __first1 != __last1; ++__first1, ++__first2)
+    if (!__binary_pred(*__first1, *__first2))
+      return false;
+  return true;
+}
+
+//--------------------------------------------------
+// lexicographical_compare and lexicographical_compare_3way.
+// (the latter is not part of the C++ standard.)
+
+template <class _InputIter1, class _InputIter2>
+bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
+                             _InputIter2 __first2, _InputIter2 __last2) {
+  for ( ; __first1 != __last1 && __first2 != __last2
+        ; ++__first1, ++__first2) {
+    if (*__first1 < *__first2)
+      return true;
+    if (*__first2 < *__first1)
+      return false;
+  }
+  return __first1 == __last1 && __first2 != __last2;
+}
+
+template <class _InputIter1, class _InputIter2, class _Compare>
+bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
+                             _InputIter2 __first2, _InputIter2 __last2,
+                             _Compare __comp) {
+  for ( ; __first1 != __last1 && __first2 != __last2
+        ; ++__first1, ++__first2) {
+    if (__comp(*__first1, *__first2))
+      return true;
+    if (__comp(*__first2, *__first1))
+      return false;
+  }
+  return __first1 == __last1 && __first2 != __last2;
+}
+
+inline bool 
+lexicographical_compare(const unsigned char* __first1,
+                        const unsigned char* __last1,
+                        const unsigned char* __first2,
+                        const unsigned char* __last2)
+{
+  const size_t __len1 = __last1 - __first1;
+  const size_t __len2 = __last2 - __first2;
+  const int __result = memcmp(__first1, __first2, min(__len1, __len2));
+  return __result != 0 ? __result < 0 : __len1 < __len2;
+}
+
+inline bool lexicographical_compare(const char* __first1, const char* __last1,
+                                    const char* __first2, const char* __last2)
+{
+#if CHAR_MAX == SCHAR_MAX
+  return lexicographical_compare((const signed char*) __first1,
+                                 (const signed char*) __last1,
+                                 (const signed char*) __first2,
+                                 (const signed char*) __last2);
+#else /* CHAR_MAX == SCHAR_MAX */
+  return lexicographical_compare((const unsigned char*) __first1,
+                                 (const unsigned char*) __last1,
+                                 (const unsigned char*) __first2,
+                                 (const unsigned char*) __last2);
+#endif /* CHAR_MAX == SCHAR_MAX */
+}
+
+template <class _InputIter1, class _InputIter2>
+int __lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1,
+                                   _InputIter2 __first2, _InputIter2 __last2)
+{
+  while (__first1 != __last1 && __first2 != __last2) {
+    if (*__first1 < *__first2)
+      return -1;
+    if (*__first2 < *__first1)
+      return 1;
+    ++__first1;
+    ++__first2;
+  }
+  if (__first2 == __last2) {
+    return !(__first1 == __last1);
+  }
+  else {
+    return -1;
+  }
+}
+
+inline int
+__lexicographical_compare_3way(const unsigned char* __first1,
+                               const unsigned char* __last1,
+                               const unsigned char* __first2,
+                               const unsigned char* __last2)
+{
+  const ptrdiff_t __len1 = __last1 - __first1;
+  const ptrdiff_t __len2 = __last2 - __first2;
+  const int __result = memcmp(__first1, __first2, min(__len1, __len2));
+  return __result != 0 ? __result 
+                       : (__len1 == __len2 ? 0 : (__len1 < __len2 ? -1 : 1));
+}
+
+inline int 
+__lexicographical_compare_3way(const char* __first1, const char* __last1,
+                               const char* __first2, const char* __last2)
+{
+#if CHAR_MAX == SCHAR_MAX
+  return __lexicographical_compare_3way(
+                                (const signed char*) __first1,
+                                (const signed char*) __last1,
+                                (const signed char*) __first2,
+                                (const signed char*) __last2);
+#else
+  return __lexicographical_compare_3way((const unsigned char*) __first1,
+                                        (const unsigned char*) __last1,
+                                        (const unsigned char*) __first2,
+                                        (const unsigned char*) __last2);
+#endif
+}
+
+template <class _InputIter1, class _InputIter2>
+int lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1,
+                                 _InputIter2 __first2, _InputIter2 __last2)
+{
+  return __lexicographical_compare_3way(__first1, __last1, __first2, __last2);
+}
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_ALGOBASE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_alloc.h b/gnu/egcs/libstdc++/stl/stl_alloc.h
new file mode 100644
index 00000000000..208309a389b
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_alloc.h
@@ -0,0 +1,1057 @@
+/*
+ * Copyright (c) 1996-1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_ALLOC_H
+#define __SGI_STL_INTERNAL_ALLOC_H
+
+#ifdef __SUNPRO_CC
+#  define __PRIVATE public
+   // Extra access restrictions prevent us from really making some things
+   // private.
+#else
+#  define __PRIVATE private
+#endif
+
+#ifdef __STL_STATIC_TEMPLATE_MEMBER_BUG
+#  define __USE_MALLOC
+#endif
+
+
+// This implements some standard node allocators.  These are
+// NOT the same as the allocators in the C++ draft standard or in
+// in the original STL.  They do not encapsulate different pointer
+// types; indeed we assume that there is only one pointer type.
+// The allocation primitives are intended to allocate individual objects,
+// not larger arenas as with the original STL allocators.
+
+#if 0
+#   include <new>
+#   define __THROW_BAD_ALLOC throw bad_alloc()
+#elif !defined(__THROW_BAD_ALLOC)
+#   include <iostream.h>
+#   define __THROW_BAD_ALLOC cerr << "out of memory" << endl; exit(1)
+#endif
+
+#ifdef __STL_WIN32THREADS
+#   include <windows.h>
+#endif
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#ifndef __RESTRICT
+#  define __RESTRICT
+#endif
+
+#if !defined(__STL_PTHREADS) && !defined(__STL_SOLTHREADS) \
+ && !defined(_NOTHREADS) \
+ && !defined(__STL_SGI_THREADS) && !defined(__STL_WIN32THREADS)
+#   define _NOTHREADS
+#endif
+
+# ifdef __STL_PTHREADS
+    // POSIX Threads
+    // This is dubious, since this is likely to be a high contention
+    // lock.   Performance may not be adequate.
+#   include <pthread.h>
+#   define __NODE_ALLOCATOR_LOCK \
+        if (threads) pthread_mutex_lock(&_S_node_allocator_lock)
+#   define __NODE_ALLOCATOR_UNLOCK \
+        if (threads) pthread_mutex_unlock(&_S_node_allocator_lock)
+#   define __NODE_ALLOCATOR_THREADS true
+#   define __VOLATILE volatile  // Needed at -O3 on SGI
+# endif
+# ifdef __STL_SOLTHREADS
+#   include <thread.h>
+#   define __NODE_ALLOCATOR_LOCK \
+	if (threads) mutex_lock(&_S_node_allocator_lock)
+#   define __NODE_ALLOCATOR_UNLOCK \
+        if (threads) mutex_unlock(&_S_node_allocator_lock)
+#   define __NODE_ALLOCATOR_THREADS true
+#   define __VOLATILE
+# endif
+# ifdef __STL_WIN32THREADS
+    // The lock needs to be initialized by constructing an allocator
+    // objects of the right type.  We do that here explicitly for alloc.
+#   define __NODE_ALLOCATOR_LOCK \
+        EnterCriticalSection(&_S_node_allocator_lock)
+#   define __NODE_ALLOCATOR_UNLOCK \
+        LeaveCriticalSection(&_S_node_allocator_lock)
+#   define __NODE_ALLOCATOR_THREADS true
+#   define __VOLATILE volatile  // may not be needed
+# endif /* WIN32THREADS */
+# ifdef __STL_SGI_THREADS
+    // This should work without threads, with sproc threads, or with
+    // pthreads.  It is suboptimal in all cases.
+    // It is unlikely to even compile on nonSGI machines.
+
+    extern "C" {
+      extern int __us_rsthread_malloc;
+    }
+	// The above is copied from malloc.h.  Including <malloc.h>
+	// would be cleaner but fails with certain levels of standard
+	// conformance.
+#   define __NODE_ALLOCATOR_LOCK if (threads && __us_rsthread_malloc) \
+                { _S_lock(&_S_node_allocator_lock); }
+#   define __NODE_ALLOCATOR_UNLOCK if (threads && __us_rsthread_malloc) \
+                { _S_unlock(&_S_node_allocator_lock); }
+#   define __NODE_ALLOCATOR_THREADS true
+#   define __VOLATILE volatile  // Needed at -O3 on SGI
+# endif
+# ifdef _NOTHREADS
+//  Thread-unsafe
+#   define __NODE_ALLOCATOR_LOCK
+#   define __NODE_ALLOCATOR_UNLOCK
+#   define __NODE_ALLOCATOR_THREADS false
+#   define __VOLATILE
+# endif
+
+__STL_BEGIN_NAMESPACE
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1174
+#endif
+
+// Malloc-based allocator.  Typically slower than default alloc below.
+// Typically thread-safe and more storage efficient.
+#ifdef __STL_STATIC_TEMPLATE_MEMBER_BUG
+# ifdef __DECLARE_GLOBALS_HERE
+    void (* __malloc_alloc_oom_handler)() = 0;
+    // g++ 2.7.2 does not handle static template data members.
+# else
+    extern void (* __malloc_alloc_oom_handler)();
+# endif
+#endif
+
+template <int __inst>
+class __malloc_alloc_template {
+
+private:
+
+  static void* _S_oom_malloc(size_t);
+  static void* _S_oom_realloc(void*, size_t);
+
+#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG
+  static void (* __malloc_alloc_oom_handler)();
+#endif
+
+public:
+
+  static void* allocate(size_t __n)
+  {
+    void* __result = malloc(__n);
+    if (0 == __result) __result = _S_oom_malloc(__n);
+    return __result;
+  }
+
+  static void deallocate(void* __p, size_t /* __n */)
+  {
+    free(__p);
+  }
+
+  static void* reallocate(void* __p, size_t /* old_sz */, size_t __new_sz)
+  {
+    void* __result = realloc(__p, __new_sz);
+    if (0 == __result) __result = _S_oom_realloc(__p, __new_sz);
+    return __result;
+  }
+
+  static void (* __set_malloc_handler(void (*__f)()))()
+  {
+    void (* __old)() = __malloc_alloc_oom_handler;
+    __malloc_alloc_oom_handler = __f;
+    return(__old);
+  }
+
+};
+
+// malloc_alloc out-of-memory handling
+
+#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG
+template <int __inst>
+void (* __malloc_alloc_template<__inst>::__malloc_alloc_oom_handler)() = 0;
+#endif
+
+template <int __inst>
+void*
+__malloc_alloc_template<__inst>::_S_oom_malloc(size_t __n)
+{
+    void (* __my_malloc_handler)();
+    void* __result;
+
+    for (;;) {
+        __my_malloc_handler = __malloc_alloc_oom_handler;
+        if (0 == __my_malloc_handler) { __THROW_BAD_ALLOC; }
+        (*__my_malloc_handler)();
+        __result = malloc(__n);
+        if (__result) return(__result);
+    }
+}
+
+template <int __inst>
+void* __malloc_alloc_template<__inst>::_S_oom_realloc(void* __p, size_t __n)
+{
+    void (* __my_malloc_handler)();
+    void* __result;
+
+    for (;;) {
+        __my_malloc_handler = __malloc_alloc_oom_handler;
+        if (0 == __my_malloc_handler) { __THROW_BAD_ALLOC; }
+        (*__my_malloc_handler)();
+        __result = realloc(__p, __n);
+        if (__result) return(__result);
+    }
+}
+
+typedef __malloc_alloc_template<0> malloc_alloc;
+
+template<class _Tp, class _Alloc>
+class simple_alloc {
+
+public:
+    static _Tp* allocate(size_t __n)
+      { return 0 == __n ? 0 : (_Tp*) _Alloc::allocate(__n * sizeof (_Tp)); }
+    static _Tp* allocate(void)
+      { return (_Tp*) _Alloc::allocate(sizeof (_Tp)); }
+    static void deallocate(_Tp* __p, size_t __n)
+      { if (0 != __n) _Alloc::deallocate(__p, __n * sizeof (_Tp)); }
+    static void deallocate(_Tp* __p)
+      { _Alloc::deallocate(__p, sizeof (_Tp)); }
+};
+
+// Allocator adaptor to check size arguments for debugging.
+// Reports errors using assert.  Checking can be disabled with
+// NDEBUG, but it's far better to just use the underlying allocator
+// instead when no checking is desired.
+// There is some evidence that this can confuse Purify.
+template <class _Alloc>
+class debug_alloc {
+
+private:
+
+  enum {_S_extra = 8};  // Size of space used to store size.  Note
+                        // that this must be large enough to preserve
+                        // alignment.
+
+public:
+
+  static void* allocate(size_t __n)
+  {
+    char* __result = (char*)_Alloc::allocate(__n + _S_extra);
+    *(size_t*)__result = __n;
+    return __result + _S_extra;
+  }
+
+  static void deallocate(void* __p, size_t __n)
+  {
+    char* __real_p = (char*)__p - _S_extra;
+    assert(*(size_t*)__real_p == __n);
+    _Alloc::deallocate(__real_p, __n + _S_extra);
+  }
+
+  static void* reallocate(void* __p, size_t __old_sz, size_t __new_sz)
+  {
+    char* __real_p = (char*)__p - _S_extra;
+    assert(*(size_t*)__real_p == __old_sz);
+    char* __result = (char*)
+      _Alloc::reallocate(__real_p, __old_sz + _S_extra, __new_sz + _S_extra);
+    *(size_t*)__result = __new_sz;
+    return __result + _S_extra;
+  }
+
+};
+
+
+# ifdef __USE_MALLOC
+
+typedef malloc_alloc alloc;
+typedef malloc_alloc single_client_alloc;
+
+# else
+
+
+// Default node allocator.
+// With a reasonable compiler, this should be roughly as fast as the
+// original STL class-specific allocators, but with less fragmentation.
+// Default_alloc_template parameters are experimental and MAY
+// DISAPPEAR in the future.  Clients should just use alloc for now.
+//
+// Important implementation properties:
+// 1. If the client request an object of size > _MAX_BYTES, the resulting
+//    object will be obtained directly from malloc.
+// 2. In all other cases, we allocate an object of size exactly
+//    _S_round_up(requested_size).  Thus the client has enough size
+//    information that we can return the object to the proper free list
+//    without permanently losing part of the object.
+//
+
+// The first template parameter specifies whether more than one thread
+// may use this allocator.  It is safe to allocate an object from
+// one instance of a default_alloc and deallocate it with another
+// one.  This effectively transfers its ownership to the second one.
+// This may have undesirable effects on reference locality.
+// The second parameter is unreferenced and serves only to allow the
+// creation of multiple default_alloc instances.
+// Node that containers built on different allocator instances have
+// different types, limiting the utility of this approach.
+#ifdef __SUNPRO_CC
+// breaks if we make these template class members:
+  enum {_ALIGN = 8};
+  enum {_MAX_BYTES = 128};
+  enum {_NFREELISTS = _MAX_BYTES/_ALIGN};
+#endif
+
+template <bool threads, int inst>
+class __default_alloc_template {
+
+private:
+  // Really we should use static const int x = N
+  // instead of enum { x = N }, but few compilers accept the former.
+# ifndef __SUNPRO_CC
+    enum {_ALIGN = 8};
+    enum {_MAX_BYTES = 128};
+    enum {_NFREELISTS = _MAX_BYTES/_ALIGN};
+# endif
+  static size_t
+  _S_round_up(size_t __bytes)
+    { return (((__bytes) + _ALIGN-1) & ~(_ALIGN - 1)); }
+
+__PRIVATE:
+  union _Obj {
+        union _Obj* _M_free_list_link;
+        char _M_client_data[1];    /* The client sees this.        */
+  };
+private:
+# ifdef __SUNPRO_CC
+    static _Obj* __VOLATILE _S_free_list[];
+        // Specifying a size results in duplicate def for 4.1
+# else
+    static _Obj* __VOLATILE _S_free_list[_NFREELISTS];
+# endif
+  static  size_t _S_freelist_index(size_t __bytes) {
+        return (((__bytes) + _ALIGN-1)/_ALIGN - 1);
+  }
+
+  // Returns an object of size __n, and optionally adds to size __n free list.
+  static void* _S_refill(size_t __n);
+  // Allocates a chunk for nobjs of size "size".  nobjs may be reduced
+  // if it is inconvenient to allocate the requested number.
+  static char* _S_chunk_alloc(size_t __size, int& __nobjs);
+
+  // Chunk allocation state.
+  static char* _S_start_free;
+  static char* _S_end_free;
+  static size_t _S_heap_size;
+
+# ifdef __STL_SGI_THREADS
+    static volatile unsigned long _S_node_allocator_lock;
+    static void _S_lock(volatile unsigned long*);
+    static inline void _S_unlock(volatile unsigned long*);
+# endif
+
+# ifdef __STL_PTHREADS
+    static pthread_mutex_t _S_node_allocator_lock;
+# endif
+
+# ifdef __STL_SOLTHREADS
+    static mutex_t _S_node_allocator_lock;
+# endif
+
+# ifdef __STL_WIN32THREADS
+    static CRITICAL_SECTION _S_node_allocator_lock;
+    static bool _S_node_allocator_lock_initialized;
+
+  public:
+    __default_alloc_template() {
+	// This assumes the first constructor is called before threads
+	// are started.
+        if (!_S_node_allocator_lock_initialized) {
+            InitializeCriticalSection(&_S_node_allocator_lock);
+            _S_node_allocator_lock_initialized = true;
+        }
+    }
+  private:
+# endif
+
+    class _Lock {
+        public:
+            _Lock() { __NODE_ALLOCATOR_LOCK; }
+            ~_Lock() { __NODE_ALLOCATOR_UNLOCK; }
+    };
+    friend class _Lock;
+
+public:
+
+  /* __n must be > 0      */
+  static void* allocate(size_t __n)
+  {
+    _Obj* __VOLATILE* __my_free_list;
+    _Obj* __RESTRICT __result;
+
+    if (__n > (size_t) _MAX_BYTES) {
+        return(malloc_alloc::allocate(__n));
+    }
+    __my_free_list = _S_free_list + _S_freelist_index(__n);
+    // Acquire the lock here with a constructor call.
+    // This ensures that it is released in exit or during stack
+    // unwinding.
+#       ifndef _NOTHREADS
+        /*REFERENCED*/
+        _Lock __lock_instance;
+#       endif
+    __result = *__my_free_list;
+    if (__result == 0) {
+        void* __r = _S_refill(_S_round_up(__n));
+        return __r;
+    }
+    *__my_free_list = __result -> _M_free_list_link;
+    return (__result);
+  };
+
+  /* __p may not be 0 */
+  static void deallocate(void* __p, size_t __n)
+  {
+    _Obj* __q = (_Obj*)__p;
+    _Obj* __VOLATILE* __my_free_list;
+
+    if (__n > (size_t) _MAX_BYTES) {
+        malloc_alloc::deallocate(__p, __n);
+        return;
+    }
+    __my_free_list = _S_free_list + _S_freelist_index(__n);
+    // acquire lock
+#       ifndef _NOTHREADS
+        /*REFERENCED*/
+        _Lock __lock_instance;
+#       endif /* _NOTHREADS */
+    __q -> _M_free_list_link = *__my_free_list;
+    *__my_free_list = __q;
+    // lock is released here
+  }
+
+  static void* reallocate(void* __p, size_t __old_sz, size_t __new_sz);
+
+} ;
+
+typedef __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0> alloc;
+typedef __default_alloc_template<false, 0> single_client_alloc;
+
+
+
+/* We allocate memory in large chunks in order to avoid fragmenting     */
+/* the malloc heap too much.                                            */
+/* We assume that size is properly aligned.                             */
+/* We hold the allocation lock.                                         */
+template <bool __threads, int __inst>
+char*
+__default_alloc_template<__threads, __inst>::_S_chunk_alloc(size_t __size,
+                                                            int& __nobjs)
+{
+    char* __result;
+    size_t __total_bytes = __size * __nobjs;
+    size_t __bytes_left = _S_end_free - _S_start_free;
+
+    if (__bytes_left >= __total_bytes) {
+        __result = _S_start_free;
+        _S_start_free += __total_bytes;
+        return(__result);
+    } else if (__bytes_left >= __size) {
+        __nobjs = (int)(__bytes_left/__size);
+        __total_bytes = __size * __nobjs;
+        __result = _S_start_free;
+        _S_start_free += __total_bytes;
+        return(__result);
+    } else {
+        size_t __bytes_to_get =
+	  2 * __total_bytes + _S_round_up(_S_heap_size >> 4);
+        // Try to make use of the left-over piece.
+        if (__bytes_left > 0) {
+            _Obj* __VOLATILE* __my_free_list =
+                        _S_free_list + _S_freelist_index(__bytes_left);
+
+            ((_Obj*)_S_start_free) -> _M_free_list_link = *__my_free_list;
+            *__my_free_list = (_Obj*)_S_start_free;
+        }
+        _S_start_free = (char*)malloc(__bytes_to_get);
+        if (0 == _S_start_free) {
+            size_t __i;
+            _Obj* __VOLATILE* __my_free_list;
+	    _Obj* __p;
+            // Try to make do with what we have.  That can't
+            // hurt.  We do not try smaller requests, since that tends
+            // to result in disaster on multi-process machines.
+            for (__i = __size; __i <= _MAX_BYTES; __i += _ALIGN) {
+                __my_free_list = _S_free_list + _S_freelist_index(__i);
+                __p = *__my_free_list;
+                if (0 != __p) {
+                    *__my_free_list = __p -> _M_free_list_link;
+                    _S_start_free = (char*)__p;
+                    _S_end_free = _S_start_free + __i;
+                    return(_S_chunk_alloc(__size, __nobjs));
+                    // Any leftover piece will eventually make it to the
+                    // right free list.
+                }
+            }
+	    _S_end_free = 0;	// In case of exception.
+            _S_start_free = (char*)malloc_alloc::allocate(__bytes_to_get);
+            // This should either throw an
+            // exception or remedy the situation.  Thus we assume it
+            // succeeded.
+        }
+        _S_heap_size += __bytes_to_get;
+        _S_end_free = _S_start_free + __bytes_to_get;
+        return(_S_chunk_alloc(__size, __nobjs));
+    }
+}
+
+
+/* Returns an object of size __n, and optionally adds to size __n free list.*/
+/* We assume that __n is properly aligned.                                */
+/* We hold the allocation lock.                                         */
+template <bool __threads, int __inst>
+void*
+__default_alloc_template<__threads, __inst>::_S_refill(size_t __n)
+{
+    int __nobjs = 20;
+    char* __chunk = _S_chunk_alloc(__n, __nobjs);
+    _Obj* __VOLATILE* __my_free_list;
+    _Obj* __result;
+    _Obj* __current_obj;
+    _Obj* __next_obj;
+    int __i;
+
+    if (1 == __nobjs) return(__chunk);
+    __my_free_list = _S_free_list + _S_freelist_index(__n);
+
+    /* Build free list in chunk */
+      __result = (_Obj*)__chunk;
+      *__my_free_list = __next_obj = (_Obj*)(__chunk + __n);
+      for (__i = 1; ; __i++) {
+        __current_obj = __next_obj;
+        __next_obj = (_Obj*)((char*)__next_obj + __n);
+        if (__nobjs - 1 == __i) {
+            __current_obj -> _M_free_list_link = 0;
+            break;
+        } else {
+            __current_obj -> _M_free_list_link = __next_obj;
+        }
+      }
+    return(__result);
+}
+
+template <bool threads, int inst>
+void*
+__default_alloc_template<threads, inst>::reallocate(void* __p,
+                                                    size_t __old_sz,
+                                                    size_t __new_sz)
+{
+    void* __result;
+    size_t __copy_sz;
+
+    if (__old_sz > (size_t) _MAX_BYTES && __new_sz > (size_t) _MAX_BYTES) {
+        return(realloc(__p, __new_sz));
+    }
+    if (_S_round_up(__old_sz) == _S_round_up(__new_sz)) return(__p);
+    __result = allocate(__new_sz);
+    __copy_sz = __new_sz > __old_sz? __old_sz : __new_sz;
+    memcpy(__result, __p, __copy_sz);
+    deallocate(__p, __old_sz);
+    return(__result);
+}
+
+#ifdef __STL_PTHREADS
+    template <bool __threads, int __inst>
+    pthread_mutex_t
+    __default_alloc_template<__threads, __inst>::_S_node_allocator_lock
+        = PTHREAD_MUTEX_INITIALIZER;
+#endif
+
+#ifdef __STL_SOLTHREADS
+    template <bool __threads, int __inst>
+    mutex_t
+    __default_alloc_template<__threads, __inst>::_S_node_allocator_lock
+        = DEFAULTMUTEX;
+#endif
+
+#ifdef __STL_WIN32THREADS
+    template <bool __threads, int __inst>
+    CRITICAL_SECTION
+    __default_alloc_template<__threads, __inst>::
+      _S_node_allocator_lock;
+
+    template <bool __threads, int __inst>
+    bool
+    __default_alloc_template<__threads, __inst>::
+      _S_node_allocator_lock_initialized
+	= false;
+#endif
+
+#ifdef __STL_SGI_THREADS
+__STL_END_NAMESPACE
+#include <mutex.h>
+#include <time.h>  /* XXX should use <ctime> */
+__STL_BEGIN_NAMESPACE
+// Somewhat generic lock implementations.  We need only test-and-set
+// and some way to sleep.  These should work with both SGI pthreads
+// and sproc threads.  They may be useful on other systems.
+template <bool __threads, int __inst>
+volatile unsigned long
+__default_alloc_template<__threads, __inst>::_S_node_allocator_lock = 0;
+
+#if __mips < 3 || !(defined (_ABIN32) || defined(_ABI64)) || defined(__GNUC__)
+#   define __test_and_set(l,v) test_and_set(l,v)
+#endif
+
+template <bool __threads, int __inst>
+void
+__default_alloc_template<__threads, __inst>::
+  _S_lock(volatile unsigned long* __lock)
+{
+    const unsigned __low_spin_max = 30;  // spins if we suspect uniprocessor
+    const unsigned __high_spin_max = 1000; // spins for multiprocessor
+    static unsigned __spin_max = __low_spin_max;
+    unsigned __my_spin_max;
+    static unsigned __last_spins = 0;
+    unsigned __my_last_spins;
+    unsigned __junk;
+#   define __ALLOC_PAUSE \
+      __junk *= __junk; __junk *= __junk; __junk *= __junk; __junk *= __junk
+    int __i;
+
+    if (!__test_and_set((unsigned long*)__lock, 1)) {
+        return;
+    }
+    __my_spin_max = __spin_max;
+    __my_last_spins = __last_spins;
+    for (__i = 0; __i < __my_spin_max; __i++) {
+        if (__i < __my_last_spins/2 || *__lock) {
+            __ALLOC_PAUSE;
+            continue;
+        }
+        if (!__test_and_set((unsigned long*)__lock, 1)) {
+            // got it!
+            // Spinning worked.  Thus we're probably not being scheduled
+            // against the other process with which we were contending.
+            // Thus it makes sense to spin longer the next time.
+            __last_spins = __i;
+            __spin_max = __high_spin_max;
+            return;
+        }
+    }
+    // We are probably being scheduled against the other process.  Sleep.
+    __spin_max = __low_spin_max;
+    for (__i = 0 ;; ++__i) {
+        struct timespec __ts;
+        int __log_nsec = __i + 6;
+
+        if (!__test_and_set((unsigned long *)__lock, 1)) {
+            return;
+        }
+        if (__log_nsec > 27) __log_nsec = 27;
+		/* Max sleep is 2**27nsec ~ 60msec      */
+        __ts.tv_sec = 0;
+        __ts.tv_nsec = 1 << __log_nsec;
+        nanosleep(&__ts, 0);
+    }
+}
+
+template <bool __threads, int __inst>
+inline void
+__default_alloc_template<__threads, __inst>::_S_unlock(
+  volatile unsigned long* __lock)
+{
+#   if defined(__GNUC__) && __mips >= 3
+        asm("sync");
+        *__lock = 0;
+#   elif __mips >= 3 && (defined (_ABIN32) || defined(_ABI64))
+        __lock_release(__lock);
+#   else
+        *__lock = 0;
+        // This is not sufficient on many multiprocessors, since
+        // writes to protected variables and the lock may be reordered.
+#   endif
+}
+#endif
+
+template <bool __threads, int __inst>
+char* __default_alloc_template<__threads, __inst>::_S_start_free = 0;
+
+template <bool __threads, int __inst>
+char* __default_alloc_template<__threads, __inst>::_S_end_free = 0;
+
+template <bool __threads, int __inst>
+size_t __default_alloc_template<__threads, __inst>::_S_heap_size = 0;
+
+template <bool __threads, int __inst>
+__default_alloc_template<__threads, __inst>::_Obj* __VOLATILE
+__default_alloc_template<__threads, __inst> ::_S_free_list[
+    _NFREELISTS
+] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };
+// The 16 zeros are necessary to make version 4.1 of the SunPro
+// compiler happy.  Otherwise it appears to allocate too little
+// space for the array.
+
+# ifdef __STL_WIN32THREADS
+  // Create one to get critical section initialized.
+  // We do this onece per file, but only the first constructor
+  // does anything.
+  static alloc __node_allocator_dummy_instance;
+# endif
+
+#endif /* ! __USE_MALLOC */
+
+// This implements allocators as specified in the C++ standard.
+//
+// Note that standard-conforming allocators use many language features
+// that are not yet widely implemented.  In particular, they rely on
+// member templates, partial specialization, partial ordering of function
+// templates, the typename keyword, and the use of the template keyword
+// to refer to a template member of a dependent type.
+
+#ifdef __STL_USE_STD_ALLOCATORS
+
+template <class _Tp>
+class allocator {
+  typedef alloc _Alloc;          // The underlying allocator.
+public:
+  typedef size_t     size_type;
+  typedef ptrdiff_t  difference_type;
+  typedef _Tp*       pointer;
+  typedef const _Tp* const_pointer;
+  typedef _Tp&       reference;
+  typedef const _Tp& const_reference;
+  typedef _Tp        value_type;
+
+  template <class _Tp1> struct rebind {
+    typedef allocator<_Tp1> other;
+  };
+
+  allocator() __STL_NOTHROW {}
+  allocator(const allocator&) __STL_NOTHROW {}
+  template <class _Tp1> allocator(const allocator<_Tp1>&) __STL_NOTHROW {}
+  ~allocator() __STL_NOTHROW {}
+
+  pointer address(reference __x) const { return &__x; }
+  const_pointer address(const_reference __x) const { return &__x; }
+
+  // __n is permitted to be 0.  The C++ standard says nothing about what
+  // the return value is when __n == 0.
+  _Tp* allocate(size_type __n, const void* = 0) {
+    return __n != 0 ? static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp)))
+                    : 0;
+  }
+
+  // __p is not permitted to be a null pointer.
+  void deallocate(pointer __p, size_type __n)
+    { _Alloc::deallocate(__p, __n * sizeof(_Tp)); }
+
+  size_type max_size() const __STL_NOTHROW
+    { return size_t(-1) / sizeof(_Tp); }
+
+  void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }
+  void destroy(pointer __p) { __p->~_Tp(); }
+};
+
+template<>
+class allocator<void> {
+  typedef size_t      size_type;
+  typedef ptrdiff_t   difference_type;
+  typedef void*       pointer;
+  typedef const void* const_pointer;
+  typedef void        value_type;
+
+  template <class _Tp1> struct rebind {
+    typedef allocator<_Tp1> other;
+  };
+};
+
+
+template <class _T1, class _T2>
+inline bool operator==(const allocator<_T1>&, const allocator<_T2>&)
+{
+  return true;
+}
+
+template <class _T1, class _T2>
+inline bool operator!=(const allocator<_T1>&, const allocator<_T2>&)
+{
+  return false;
+}
+
+// Allocator adaptor to turn an SGI-style allocator (e.g. alloc, malloc_alloc)
+// into a standard-conforming allocator.   Note that this adaptor does
+// *not* assume that all objects of the underlying alloc class are
+// identical, nor does it assume that all of the underlying alloc's
+// member functions are static member functions.  Note, also, that
+// __allocator<_Tp, alloc> is essentially the same thing as allocator<_Tp>.
+
+template <class _Tp, class _Alloc>
+struct __allocator {
+  _Alloc __underlying_alloc;
+
+  typedef size_t    size_type;
+  typedef ptrdiff_t difference_type;
+  typedef _Tp*       pointer;
+  typedef const _Tp* const_pointer;
+  typedef _Tp&       reference;
+  typedef const _Tp& const_reference;
+  typedef _Tp        value_type;
+
+  template <class _Tp1> struct rebind {
+    typedef __allocator<_Tp1, _Alloc> other;
+  };
+
+  __allocator() __STL_NOTHROW {}
+  __allocator(const __allocator& __a) __STL_NOTHROW
+    : __underlying_alloc(__a.__underlying_alloc) {}
+  template <class _Tp1>
+  __allocator(const __allocator<_Tp1, _Alloc>& __a) __STL_NOTHROW
+    : __underlying_alloc(__a.__underlying_alloc) {}
+  ~__allocator() __STL_NOTHROW {}
+
+  pointer address(reference __x) const { return &__x; }
+  const_pointer address(const_reference __x) const { return &__x; }
+
+  // __n is permitted to be 0.
+  _Tp* allocate(size_type __n, const void* = 0) {
+    return __n != 0
+        ? static_cast<_Tp*>(__underlying_alloc.allocate(__n * sizeof(_Tp)))
+        : 0;
+  }
+
+  // __p is not permitted to be a null pointer.
+  void deallocate(pointer __p, size_type __n)
+    { __underlying_alloc.deallocate(__p, __n * sizeof(_Tp)); }
+
+  size_type max_size() const __STL_NOTHROW
+    { return size_t(-1) / sizeof(_Tp); }
+
+  void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }
+  void destroy(pointer __p) { __p->~_Tp(); }
+};
+
+template <class _Alloc>
+class __allocator<void, _Alloc> {
+  typedef size_t      size_type;
+  typedef ptrdiff_t   difference_type;
+  typedef void*       pointer;
+  typedef const void* const_pointer;
+  typedef void        value_type;
+
+  template <class _Tp1> struct rebind {
+    typedef __allocator<_Tp1, _Alloc> other;
+  };
+};
+
+template <class _Tp, class _Alloc>
+inline bool operator==(const __allocator<_Tp, _Alloc>& __a1,
+                       const __allocator<_Tp, _Alloc>& __a2)
+{
+  return __a1.__underlying_alloc == __a2.__underlying_alloc;
+}
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+template <class _Tp, class _Alloc>
+inline bool operator!=(const __allocator<_Tp, _Alloc>& __a1,
+                       const __allocator<_Tp, _Alloc>& __a2)
+{
+  return __a1.__underlying_alloc != __a2.__underlying_alloc;
+}
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+// Comparison operators for all of the predifined SGI-style allocators.
+// This ensures that __allocator<malloc_alloc> (for example) will
+// work correctly.
+
+template <int inst>
+inline bool operator==(const __malloc_alloc_template<inst>&,
+                       const __malloc_alloc_template<inst>&)
+{
+  return true;
+}
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+template <int __inst>
+inline bool operator!=(const __malloc_alloc_template<__inst>&,
+                       const __malloc_alloc_template<__inst>&)
+{
+  return false;
+}
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+#ifndef __USE_MALLOC
+template <bool __threads, int __inst>
+inline bool operator==(const __default_alloc_template<__threads, __inst>&,
+                       const __default_alloc_template<__threads, __inst>&)
+{
+  return true;
+}
+
+# ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+template <bool __threads, int __inst>
+inline bool operator!=(const __default_alloc_template<__threads, __inst>&,
+                       const __default_alloc_template<__threads, __inst>&)
+{
+  return false;
+}
+# endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+#endif
+
+template <class _Alloc>
+inline bool operator==(const debug_alloc<_Alloc>&,
+                       const debug_alloc<_Alloc>&) {
+  return true;
+}
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+template <class _Alloc>
+inline bool operator!=(const debug_alloc<_Alloc>&,
+                       const debug_alloc<_Alloc>&) {
+  return false;
+}
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+// Another allocator adaptor: _Alloc_traits.  This serves two
+// purposes.  First, make it possible to write containers that can use
+// either SGI-style allocators or standard-conforming allocator.
+// Second, provide a mechanism so that containers can query whether or
+// not the allocator has distinct instances.  If not, the container
+// can avoid wasting a word of memory to store an empty object.
+
+// This adaptor uses partial specialization.  The general case of
+// _Alloc_traits<_Tp, _Alloc> assumes that _Alloc is a
+// standard-conforming allocator, possibly with non-equal instances
+// and non-static members.  (It still behaves correctly even if _Alloc
+// has static member and if all instances are equal.  Refinements
+// affect performance, not correctness.)
+
+// There are always two members: allocator_type, which is a standard-
+// conforming allocator type for allocating objects of type _Tp, and
+// _S_instanceless, a static const member of type bool.  If
+// _S_instanceless is true, this means that there is no difference
+// between any two instances of type allocator_type.  Furthermore, if
+// _S_instanceless is true, then _Alloc_traits has one additional
+// member: _Alloc_type.  This type encapsulates allocation and
+// deallocation of objects of type _Tp through a static interface; it
+// has two member functions, whose signatures are
+//    static _Tp* allocate(size_t)
+//    static void deallocate(_Tp*, size_t)
+
+// The fully general version.
+
+template <class _Tp, class _Allocator>
+struct _Alloc_traits
+{
+  static const bool _S_instanceless = false;
+  typedef typename _Allocator::__STL_TEMPLATE rebind<_Tp>::other
+          allocator_type;
+};
+
+template <class _Tp, class _Allocator>
+const bool _Alloc_traits<_Tp, _Allocator>::_S_instanceless;
+
+// The version for the default allocator.
+
+template <class _Tp, class _Tp1>
+struct _Alloc_traits<_Tp, allocator<_Tp1> >
+{
+  static const bool _S_instanceless = true;
+  typedef simple_alloc<_Tp, alloc> _Alloc_type;
+  typedef allocator<_Tp> allocator_type;
+};
+
+// Versions for the predefined SGI-style allocators.
+
+template <class _Tp, int __inst>
+struct _Alloc_traits<_Tp, __malloc_alloc_template<__inst> >
+{
+  static const bool _S_instanceless = true;
+  typedef simple_alloc<_Tp, __malloc_alloc_template<__inst> > _Alloc_type;
+  typedef __allocator<_Tp, __malloc_alloc_template<__inst> > allocator_type;
+};
+
+#ifndef __USE_MALLOC
+template <class _Tp, bool __threads, int __inst>
+struct _Alloc_traits<_Tp, __default_alloc_template<__threads, __inst> >
+{
+  static const bool _S_instanceless = true;
+  typedef simple_alloc<_Tp, __default_alloc_template<__threads, __inst> >
+          _Alloc_type;
+  typedef __allocator<_Tp, __default_alloc_template<__threads, __inst> >
+          allocator_type;
+};
+#endif
+
+template <class _Tp, class _Alloc>
+struct _Alloc_traits<_Tp, debug_alloc<_Alloc> >
+{
+  static const bool _S_instanceless = true;
+  typedef simple_alloc<_Tp, debug_alloc<_Alloc> > _Alloc_type;
+  typedef __allocator<_Tp, debug_alloc<_Alloc> > allocator_type;
+};
+
+// Versions for the __allocator adaptor used with the predefined
+// SGI-style allocators.
+
+template <class _Tp, class _Tp1, int __inst>
+struct _Alloc_traits<_Tp,
+                     __allocator<_Tp1, __malloc_alloc_template<__inst> > >
+{
+  static const bool _S_instanceless = true;
+  typedef simple_alloc<_Tp, __malloc_alloc_template<__inst> > _Alloc_type;
+  typedef __allocator<_Tp, __malloc_alloc_template<__inst> > allocator_type;
+};
+
+#ifndef __USE_MALLOC
+template <class _Tp, class _Tp1, bool __thr, int __inst>
+struct _Alloc_traits<_Tp,
+                      __allocator<_Tp1,
+                                  __default_alloc_template<__thr, __inst> > >
+{
+  static const bool _S_instanceless = true;
+  typedef simple_alloc<_Tp, __default_alloc_template<__thr,__inst> >
+          _Alloc_type;
+  typedef __allocator<_Tp, __default_alloc_template<__thr,__inst> >
+          allocator_type;
+};
+#endif
+
+template <class _Tp, class _Tp1, class _Alloc>
+struct _Alloc_traits<_Tp, __allocator<_Tp1, debug_alloc<_Alloc> > >
+{
+  static const bool _S_instanceless = true;
+  typedef simple_alloc<_Tp, debug_alloc<_Alloc> > _Alloc_type;
+  typedef __allocator<_Tp, debug_alloc<_Alloc> > allocator_type;
+};
+
+
+#endif /* __STL_USE_STD_ALLOCATORS */
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1174
+#endif
+
+__STL_END_NAMESPACE
+
+#undef __PRIVATE
+
+#endif /* __SGI_STL_INTERNAL_ALLOC_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_bvector.h b/gnu/egcs/libstdc++/stl/stl_bvector.h
new file mode 100644
index 00000000000..0d0cdb6c828
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_bvector.h
@@ -0,0 +1,838 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_BVECTOR_H
+#define __SGI_STL_INTERNAL_BVECTOR_H
+
+__STL_BEGIN_NAMESPACE 
+
+static const int __WORD_BIT = int(CHAR_BIT*sizeof(unsigned int));
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1174
+#pragma set woff 1375
+#endif
+
+struct _Bit_reference {
+  unsigned int* _M_p;
+  unsigned int _M_mask;
+  _Bit_reference(unsigned int* __x, unsigned int __y) 
+    : _M_p(__x), _M_mask(__y) {}
+
+public:
+  _Bit_reference() : _M_p(0), _M_mask(0) {}
+  operator bool() const { return !(!(*_M_p & _M_mask)); }
+  _Bit_reference& operator=(bool __x)
+  {
+    if (__x)  *_M_p |= _M_mask;
+    else      *_M_p &= ~_M_mask;
+    return *this;
+  }
+  _Bit_reference& operator=(const _Bit_reference& __x) 
+    { return *this = bool(__x); }
+  bool operator==(const _Bit_reference& __x) const
+    { return bool(*this) == bool(__x); }
+  bool operator<(const _Bit_reference& __x) const {
+    return !bool(*this) && bool(__x);
+  }
+  void flip() { *_M_p ^= _M_mask; }
+};
+
+inline void swap(_Bit_reference __x, _Bit_reference __y)
+{
+  bool __tmp = __x;
+  __x = __y;
+  __y = __tmp;
+}
+
+struct _Bit_iterator : public random_access_iterator<bool, ptrdiff_t> {
+  typedef _Bit_reference  reference;
+  typedef _Bit_reference* pointer;
+  typedef _Bit_iterator   iterator;
+
+  unsigned int* _M_p;
+  unsigned int _M_offset;
+  void bump_up() {
+    if (_M_offset++ == __WORD_BIT - 1) {
+      _M_offset = 0;
+      ++_M_p;
+    }
+  }
+  void bump_down() {
+    if (_M_offset-- == 0) {
+      _M_offset = __WORD_BIT - 1;
+      --_M_p;
+    }
+  }
+
+  _Bit_iterator() : _M_p(0), _M_offset(0) {}
+  _Bit_iterator(unsigned int* __x, unsigned int __y) 
+    : _M_p(__x), _M_offset(__y) {}
+  reference operator*() const { return reference(_M_p, 1U << _M_offset); }
+  iterator& operator++() {
+    bump_up();
+    return *this;
+  }
+  iterator operator++(int) {
+    iterator __tmp = *this;
+    bump_up();
+    return __tmp;
+  }
+  iterator& operator--() {
+    bump_down();
+    return *this;
+  }
+  iterator operator--(int) {
+    iterator __tmp = *this;
+    bump_down();
+    return __tmp;
+  }
+  iterator& operator+=(difference_type __i) {
+    difference_type __n = __i + _M_offset;
+    _M_p += __n / __WORD_BIT;
+    __n = __n % __WORD_BIT;
+    if (__n < 0) {
+      _M_offset = (unsigned int) __n + __WORD_BIT;
+      --_M_p;
+    } else
+      _M_offset = (unsigned int) __n;
+    return *this;
+  }
+  iterator& operator-=(difference_type __i) {
+    *this += -__i;
+    return *this;
+  }
+  iterator operator+(difference_type __i) const {
+    iterator __tmp = *this;
+    return __tmp += __i;
+  }
+  iterator operator-(difference_type __i) const {
+    iterator __tmp = *this;
+    return __tmp -= __i;
+  }
+  difference_type operator-(iterator __x) const {
+    return __WORD_BIT * (_M_p - __x._M_p) + _M_offset - __x._M_offset;
+  }
+  reference operator[](difference_type __i) { return *(*this + __i); }
+  bool operator==(const iterator& __x) const {
+    return _M_p == __x._M_p && _M_offset == __x._M_offset;
+  }
+  bool operator!=(const iterator& __x) const {
+    return _M_p != __x._M_p || _M_offset != __x._M_offset;
+  }
+  bool operator<(iterator __x) const {
+    return _M_p < __x._M_p || (_M_p == __x._M_p && _M_offset < __x._M_offset);
+  }
+};
+
+struct _Bit_const_iterator
+  : public random_access_iterator<bool, ptrdiff_t>
+{
+  typedef bool                 reference;
+  typedef bool                 const_reference;
+  typedef const bool*          pointer;
+  typedef _Bit_const_iterator  const_iterator;
+
+  unsigned int* _M_p;
+  unsigned int _M_offset;
+  void bump_up() {
+    if (_M_offset++ == __WORD_BIT - 1) {
+      _M_offset = 0;
+      ++_M_p;
+    }
+  }
+  void bump_down() {
+    if (_M_offset-- == 0) {
+      _M_offset = __WORD_BIT - 1;
+      --_M_p;
+    }
+  }
+
+  _Bit_const_iterator() : _M_p(0), _M_offset(0) {}
+  _Bit_const_iterator(unsigned int* __x, unsigned int __y) 
+    : _M_p(__x), _M_offset(__y) {}
+  _Bit_const_iterator(const _Bit_iterator& __x) 
+    : _M_p(__x._M_p), _M_offset(__x._M_offset) {}
+  const_reference operator*() const {
+    return _Bit_reference(_M_p, 1U << _M_offset);
+  }
+  const_iterator& operator++() {
+    bump_up();
+    return *this;
+  }
+  const_iterator operator++(int) {
+    const_iterator __tmp = *this;
+    bump_up();
+    return __tmp;
+  }
+  const_iterator& operator--() {
+    bump_down();
+    return *this;
+  }
+  const_iterator operator--(int) {
+    const_iterator __tmp = *this;
+    bump_down();
+    return __tmp;
+  }
+  const_iterator& operator+=(difference_type __i) {
+    difference_type __n = __i + _M_offset;
+    _M_p += __n / __WORD_BIT;
+    __n = __n % __WORD_BIT;
+    if (__n < 0) {
+      _M_offset = (unsigned int) __n + __WORD_BIT;
+      --_M_p;
+    } else
+      _M_offset = (unsigned int) __n;
+    return *this;
+  }
+  const_iterator& operator-=(difference_type __i) {
+    *this += -__i;
+    return *this;
+  }
+  const_iterator operator+(difference_type __i) const {
+    const_iterator __tmp = *this;
+    return __tmp += __i;
+  }
+  const_iterator operator-(difference_type __i) const {
+    const_iterator __tmp = *this;
+    return __tmp -= __i;
+  }
+  difference_type operator-(const_iterator __x) const {
+    return __WORD_BIT * (_M_p - __x._M_p) + _M_offset - __x._M_offset;
+  }
+  const_reference operator[](difference_type __i) { 
+    return *(*this + __i); 
+  }
+  bool operator==(const const_iterator& __x) const {
+    return _M_p == __x._M_p && _M_offset == __x._M_offset;
+  }
+  bool operator!=(const const_iterator& __x) const {
+    return _M_p != __x._M_p || _M_offset != __x._M_offset;
+  }
+  bool operator<(const_iterator __x) const {
+    return _M_p < __x._M_p || (_M_p == __x._M_p && _M_offset < __x._M_offset);
+  }
+};
+
+// Bit-vector base class, which encapsulates the difference between
+//  old SGI-style allocators and standard-conforming allocators.
+
+#ifdef __STL_USE_STD_ALLOCATORS
+
+// Base class for ordinary allocators.
+template <class _Allocator, bool __is_static>
+class _Bvector_alloc_base {
+public:
+  typedef typename _Alloc_traits<bool, _Allocator>::allocator_type
+          allocator_type;
+  allocator_type get_allocator() const { return _M_data_allocator; }
+
+  _Bvector_alloc_base(const allocator_type& __a)
+    : _M_data_allocator(__a), _M_start(), _M_finish(), _M_end_of_storage(0) {}
+
+protected:
+  unsigned int* _M_bit_alloc(size_t __n) 
+    { return _M_data_allocator.allocate((__n + __WORD_BIT - 1)/__WORD_BIT); }
+  void _M_deallocate() {
+    if (_M_start._M_p)
+      _M_data_allocator.deallocate(_M_start._M_p, 
+                                   _M_end_of_storage - _M_start._M_p);
+  }  
+
+  typename _Alloc_traits<unsigned int, _Allocator>::allocator_type 
+          _M_data_allocator;
+  _Bit_iterator _M_start;
+  _Bit_iterator _M_finish;
+  unsigned int* _M_end_of_storage;
+};
+
+// Specialization for instanceless allocators.
+template <class _Allocator>
+class _Bvector_alloc_base<_Allocator, true> {
+public:
+  typedef typename _Alloc_traits<bool, _Allocator>::allocator_type
+          allocator_type;
+  allocator_type get_allocator() const { return allocator_type(); }
+
+  _Bvector_alloc_base(const allocator_type&)
+    : _M_start(), _M_finish(), _M_end_of_storage(0) {}
+
+protected:
+  typedef typename _Alloc_traits<unsigned int, _Allocator>::_Alloc_type
+          _Alloc_type;
+          
+  unsigned int* _M_bit_alloc(size_t __n) 
+    { return _Alloc_type::allocate((__n + __WORD_BIT - 1)/__WORD_BIT); }
+  void _M_deallocate() {
+    if (_M_start._M_p)
+      _Alloc_type::deallocate(_M_start._M_p,
+                              _M_end_of_storage - _M_start._M_p);
+  }  
+
+  _Bit_iterator _M_start;
+  _Bit_iterator _M_finish;
+  unsigned int* _M_end_of_storage;
+};  
+
+template <class _Alloc>
+class _Bvector_base
+  : public _Bvector_alloc_base<_Alloc,
+                               _Alloc_traits<bool, _Alloc>::_S_instanceless>
+{
+  typedef _Bvector_alloc_base<_Alloc,
+                              _Alloc_traits<bool, _Alloc>::_S_instanceless>
+          _Base;
+public:
+  typedef typename _Base::allocator_type allocator_type;
+
+  _Bvector_base(const allocator_type& __a) : _Base(__a) {}
+  ~_Bvector_base() { _Base::_M_deallocate(); }
+};
+
+#else /* __STL_USE_STD_ALLOCATORS */
+
+template <class _Alloc>
+class _Bvector_base
+{
+public:
+  typedef _Alloc allocator_type;
+  allocator_type get_allocator() const { return allocator_type(); }
+
+  _Bvector_base(const allocator_type&)
+    : _M_start(), _M_finish(), _M_end_of_storage(0) {}
+  ~_Bvector_base() { _M_deallocate(); }
+
+protected:
+  typedef simple_alloc<unsigned int, _Alloc> _Alloc_type;
+  
+  unsigned int* _M_bit_alloc(size_t __n) 
+    { return _Alloc_type::allocate((__n + __WORD_BIT - 1)/__WORD_BIT); }
+  void _M_deallocate() {
+    if (_M_start._M_p)
+      _Alloc_type::deallocate(_M_start._M_p,
+                              _M_end_of_storage - _M_start._M_p);
+  }
+
+  _Bit_iterator _M_start;
+  _Bit_iterator _M_finish;
+  unsigned int* _M_end_of_storage;  
+};
+
+#endif /* __STL_USE_STD_ALLOCATORS */
+
+// The next few lines are confusing.  What we're doing is declaring a
+//  partial specialization of vector<T, Alloc> if we have the necessary
+//  compiler support.  Otherwise, we define a class bit_vector which uses
+//  the default allocator. 
+
+#if defined(__STL_CLASS_PARTIAL_SPECIALIZATION) && !defined(__STL_NO_BOOL)
+#define __SGI_STL_VECBOOL_TEMPLATE
+#define __BVECTOR vector
+#else
+#undef __SGI_STL_VECBOOL_TEMPLATE
+#define __BVECTOR bit_vector
+#endif
+
+#      ifdef __SGI_STL_VECBOOL_TEMPLATE
+       __STL_END_NAMESPACE
+#      include <stl_vector.h>
+       __STL_BEGIN_NAMESPACE
+template<class _Alloc> class vector<bool,_Alloc>
+  : public _Bvector_base<_Alloc>
+#      else /* __SGI_STL_VECBOOL_TEMPLATE */
+class bit_vector
+  : public _Bvector_base<__STL_DEFAULT_ALLOCATOR(bool) >
+#      endif /* __SGI_STL_VECBOOL_TEMPLATE */
+{
+#      ifdef __SGI_STL_VECBOOL_TEMPLATE
+  typedef _Bvector_base<_Alloc> _Base;
+#      else /* __SGI_STL_VECBOOL_TEMPLATE */
+  typedef _Bvector_base<__STL_DEFAULT_ALLOCATOR(bool) > _Base;
+#      endif /* __SGI_STL_VECBOOL_TEMPLATE */
+public:
+  typedef bool value_type;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type; 
+  typedef _Bit_reference reference;
+  typedef bool const_reference;
+  typedef _Bit_reference* pointer;
+  typedef const bool* const_pointer;
+
+  typedef _Bit_iterator                iterator;
+  typedef _Bit_const_iterator          const_iterator;
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+  typedef reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef reverse_iterator<iterator> reverse_iterator;
+#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+  typedef reverse_iterator<const_iterator, value_type, const_reference, 
+                           difference_type> const_reverse_iterator;
+  typedef reverse_iterator<iterator, value_type, reference, difference_type>
+          reverse_iterator;
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+  typedef typename _Base::allocator_type allocator_type;
+  allocator_type get_allocator() const { return _Base::get_allocator(); }
+
+protected:
+#ifdef __STL_USE_NAMESPACES  
+  using _Base::_M_bit_alloc;
+  using _Base::_M_deallocate;
+  using _Base::_M_start;
+  using _Base::_M_finish;
+  using _Base::_M_end_of_storage;
+#endif /* __STL_USE_NAMESPACES */
+
+protected:
+  void _M_initialize(size_type __n) {
+    unsigned int* __q = _M_bit_alloc(__n);
+    _M_end_of_storage = __q + (__n + __WORD_BIT - 1)/__WORD_BIT;
+    _M_start = iterator(__q, 0);
+    _M_finish = _M_start + difference_type(__n);
+  }
+  void _M_insert_aux(iterator __position, bool __x) {
+    if (_M_finish._M_p != _M_end_of_storage) {
+      copy_backward(__position, _M_finish, _M_finish + 1);
+      *__position = __x;
+      ++_M_finish;
+    }
+    else {
+      size_type __len = size() ? 2 * size() : __WORD_BIT;
+      unsigned int* __q = _M_bit_alloc(__len);
+      iterator __i = copy(begin(), __position, iterator(__q, 0));
+      *__i++ = __x;
+      _M_finish = copy(__position, end(), __i);
+      _M_deallocate();
+      _M_end_of_storage = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
+      _M_start = iterator(__q, 0);
+    }
+  }
+
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  void _M_initialize_range(_InputIterator __first, _InputIterator __last,
+                           input_iterator_tag) {
+    _M_start = iterator();
+    _M_finish = iterator();
+    _M_end_of_storage = 0;
+    for ( ; __first != __last; ++__first) 
+      push_back(*__first);
+  }
+
+  template <class _ForwardIterator>
+  void _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
+                           forward_iterator_tag) {
+    size_type __n = 0;
+    distance(__first, __last, __n);
+    _M_initialize(__n);
+    copy(__first, __last, _M_start);
+  }
+
+  template <class _InputIterator>
+  void _M_insert_range(iterator __pos,
+                       _InputIterator __first, _InputIterator __last,
+                       input_iterator_tag) {
+    for ( ; __first != __last; ++__first) {
+      __pos = insert(__pos, *__first);
+      ++__pos;
+    }
+  }
+
+  template <class _ForwardIterator>
+  void _M_insert_range(iterator __position,
+                       _ForwardIterator __first, _ForwardIterator __last,
+                       forward_iterator_tag) {
+    if (__first != __last) {
+      size_type __n = 0;
+      distance(__first, __last, __n);
+      if (capacity() - size() >= __n) {
+        copy_backward(__position, end(), _M_finish + difference_type(__n));
+        copy(__first, __last, __position);
+        _M_finish += difference_type(__n);
+      }
+      else {
+        size_type __len = size() + max(size(), __n);
+        unsigned int* __q = _M_bit_alloc(__len);
+        iterator __i = copy(begin(), __position, iterator(__q, 0));
+        __i = copy(__first, __last, __i);
+        _M_finish = copy(__position, end(), __i);
+        _M_deallocate();
+        _M_end_of_storage = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
+        _M_start = iterator(__q, 0);
+      }
+    }
+  }      
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+public:
+  iterator begin() { return _M_start; }
+  const_iterator begin() const { return _M_start; }
+  iterator end() { return _M_finish; }
+  const_iterator end() const { return _M_finish; }
+
+  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()); 
+  }
+
+  size_type size() const { return size_type(end() - begin()); }
+  size_type max_size() const { return size_type(-1); }
+  size_type capacity() const {
+    return size_type(const_iterator(_M_end_of_storage, 0) - begin());
+  }
+  bool empty() const { return begin() == end(); }
+  reference operator[](size_type __n) {
+    return *(begin() + difference_type(__n));
+  }
+  const_reference operator[](size_type __n) const {
+    return *(begin() + difference_type(__n));
+  }
+
+  explicit __BVECTOR(const allocator_type& __a = allocator_type())
+    : _Base(__a) {}
+
+  __BVECTOR(size_type __n, bool __value,
+            const allocator_type& __a = allocator_type())
+    : _Base(__a)
+  {
+    _M_initialize(__n);
+    fill(_M_start._M_p, _M_end_of_storage, __value ? ~0 : 0);
+  }
+
+  explicit __BVECTOR(size_type __n)
+    : _Base(allocator_type())
+  {
+    _M_initialize(__n);
+    fill(_M_start._M_p, _M_end_of_storage, 0);
+  }
+
+  __BVECTOR(const __BVECTOR& __x) : _Base(__x.get_allocator()) {
+    _M_initialize(__x.size());
+    copy(__x.begin(), __x.end(), _M_start);
+  }
+
+#ifdef __STL_MEMBER_TEMPLATES
+  // Check whether it's an integral type.  If so, it's not an iterator.
+  template <class _InputIterator>
+  __BVECTOR(_InputIterator __first, _InputIterator __last,
+            const allocator_type& __a = allocator_type())
+    : _Base(__a)
+  {
+    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
+    _M_initialize_dispatch(__first, __last, _Integral());
+  }
+    
+  template <class _Integer>
+  void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) {
+    _M_initialize(__n);
+    fill(_M_start._M_p, _M_end_of_storage, __x ? ~0 : 0);
+  }
+    
+  template <class _InputIterator>
+  void _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+                              __false_type) {
+    _M_initialize_range(__first, __last, __ITERATOR_CATEGORY(__first));
+  }
+#else /* __STL_MEMBER_TEMPLATES */
+  __BVECTOR(const_iterator __first, const_iterator __last,
+            const allocator_type& __a = allocator_type())
+    : _Base(__a)
+  {
+    size_type __n = 0;
+    distance(__first, __last, __n);
+    _M_initialize(__n);
+    copy(__first, __last, _M_start);
+  }
+  __BVECTOR(const bool* __first, const bool* __last,
+            const allocator_type& __a = allocator_type())
+    : _Base(__a)
+  {
+    size_type __n = 0;
+    distance(__first, __last, __n);
+    _M_initialize(__n);
+    copy(__first, __last, _M_start);
+  }
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  ~__BVECTOR() { }
+
+  __BVECTOR& operator=(const __BVECTOR& __x) {
+    if (&__x == this) return *this;
+    if (__x.size() > capacity()) {
+      _M_deallocate();
+      _M_initialize(__x.size());
+    }
+    copy(__x.begin(), __x.end(), begin());
+    _M_finish = begin() + difference_type(__x.size());
+    return *this;
+  }
+
+  // assign(), a generalized assignment member function.  Two
+  // versions: one that takes a count, and one that takes a range.
+  // The range version is a member template, so we dispatch on whether
+  // or not the type is an integer.
+
+  void assign(size_t __n, bool __x) {
+    if (__n > size()) {
+      fill(_M_start._M_p, _M_end_of_storage, __x ? ~0 : 0);
+      insert(end(), __n - size(), __x);
+    }
+    else {
+      erase(begin() + __n, end());
+      fill(_M_start._M_p, _M_end_of_storage, __x ? ~0 : 0);
+    }
+  }
+
+#ifdef __STL_MEMBER_TEMPLATES
+
+  template <class _InputIterator>
+  void assign(_InputIterator __first, _InputIterator __last) {
+    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
+    _M_assign_dispatch(__first, __last, _Integral());
+  }
+
+  template <class _Integer>
+  void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+    { assign((size_t) __n, (bool) __val); }
+
+  template <class _InputIter>
+  void _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type)
+    { _M_assign_aux(__first, __last, __ITERATOR_CATEGORY(__first)); }
+
+  template <class _InputIterator>
+  void _M_assign_aux(_InputIterator __first, _InputIterator __last,
+                     input_iterator_tag) {
+    iterator __cur = begin();
+    for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
+      *__cur = *__first;
+    if (__first == __last)
+      erase(__cur, end());
+    else
+      insert(end(), __first, __last);
+  }
+
+  template <class _ForwardIterator>
+  void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+                     forward_iterator_tag) {
+    size_type __len = 0;
+    distance(__first, __last, __len);
+    if (__len < size())
+      erase(copy(__first, __last, begin()), end());
+    else {
+      _ForwardIterator __mid = __first;
+      advance(__mid, size());
+      copy(__first, __mid, begin());
+      insert(end(), __mid, __last);
+    }
+  }    
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  void reserve(size_type __n) {
+    if (capacity() < __n) {
+      unsigned int* __q = _M_bit_alloc(__n);
+      _M_finish = copy(begin(), end(), iterator(__q, 0));
+      _M_deallocate();
+      _M_start = iterator(__q, 0);
+      _M_end_of_storage = __q + (__n + __WORD_BIT - 1)/__WORD_BIT;
+    }
+  }
+
+  reference front() { return *begin(); }
+  const_reference front() const { return *begin(); }
+  reference back() { return *(end() - 1); }
+  const_reference back() const { return *(end() - 1); }
+  void push_back(bool __x) {
+    if (_M_finish._M_p != _M_end_of_storage)
+      *_M_finish++ = __x;
+    else
+      _M_insert_aux(end(), __x);
+  }
+  void swap(__BVECTOR& __x) {
+    __STD::swap(_M_start, __x._M_start);
+    __STD::swap(_M_finish, __x._M_finish);
+    __STD::swap(_M_end_of_storage, __x._M_end_of_storage);
+  }
+  iterator insert(iterator __position, bool __x = bool()) {
+    difference_type __n = __position - begin();
+    if (_M_finish._M_p != _M_end_of_storage && __position == end())
+      *_M_finish++ = __x;
+    else
+      _M_insert_aux(__position, __x);
+    return begin() + __n;
+  }
+
+#ifdef __STL_MEMBER_TEMPLATES
+  // Check whether it's an integral type.  If so, it's not an iterator.
+  template <class _InputIterator>
+  void insert(iterator __position,
+              _InputIterator __first, _InputIterator __last) {
+    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
+    _M_insert_dispatch(__position, __first, __last, _Integral());
+  }
+
+  template <class _Integer>
+  void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
+                          __true_type) {
+    insert(__pos, (size_type) __n, (bool) __x);
+  }
+
+  template <class _InputIterator>
+  void _M_insert_dispatch(iterator __pos,
+                          _InputIterator __first, _InputIterator __last,
+                          __false_type) {
+    _M_insert_range(__pos, __first, __last, __ITERATOR_CATEGORY(__first));
+  }
+#else /* __STL_MEMBER_TEMPLATES */
+  void insert(iterator __position,
+              const_iterator __first, const_iterator __last) {
+    if (__first == __last) return;
+    size_type __n = 0;
+    distance(__first, __last, __n);
+    if (capacity() - size() >= __n) {
+      copy_backward(__position, end(), _M_finish + __n);
+      copy(__first, __last, __position);
+      _M_finish += __n;
+    }
+    else {
+      size_type __len = size() + max(size(), __n);
+      unsigned int* __q = _M_bit_alloc(__len);
+      iterator __i = copy(begin(), __position, iterator(__q, 0));
+      __i = copy(__first, __last, __i);
+      _M_finish = copy(__position, end(), __i);
+      _M_deallocate();
+      _M_end_of_storage = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
+      _M_start = iterator(__q, 0);
+    }
+  }
+
+  void insert(iterator __position, const bool* __first, const bool* __last) {
+    if (__first == __last) return;
+    size_type __n = 0;
+    distance(__first, __last, __n);
+    if (capacity() - size() >= __n) {
+      copy_backward(__position, end(), _M_finish + __n);
+      copy(__first, __last, __position);
+      _M_finish += __n;
+    }
+    else {
+      size_type __len = size() + max(size(), __n);
+      unsigned int* __q = _M_bit_alloc(__len);
+      iterator __i = copy(begin(), __position, iterator(__q, 0));
+      __i = copy(__first, __last, __i);
+      _M_finish = copy(__position, end(), __i);
+      _M_deallocate();
+      _M_end_of_storage = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
+      _M_start = iterator(__q, 0);
+    }
+  }
+#endif /* __STL_MEMBER_TEMPLATES */
+  
+  void insert(iterator __position, size_type __n, bool __x) {
+    if (__n == 0) return;
+    if (capacity() - size() >= __n) {
+      copy_backward(__position, end(), _M_finish + difference_type(__n));
+      fill(__position, __position + difference_type(__n), __x);
+      _M_finish += difference_type(__n);
+    }
+    else {
+      size_type __len = size() + max(size(), __n);
+      unsigned int* __q = _M_bit_alloc(__len);
+      iterator __i = copy(begin(), __position, iterator(__q, 0));
+      fill_n(__i, __n, __x);
+      _M_finish = copy(__position, end(), __i + difference_type(__n));
+      _M_deallocate();
+      _M_end_of_storage = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
+      _M_start = iterator(__q, 0);
+    }
+  }
+
+  void pop_back() { --_M_finish; }
+  iterator erase(iterator __position) {
+    if (__position + 1 != end())
+      copy(__position + 1, end(), __position);
+      --_M_finish;
+    return __position;
+  }
+  iterator erase(iterator __first, iterator __last) {
+    _M_finish = copy(__last, end(), __first);
+    return __first;
+  }
+  void resize(size_type __new_size, bool __x = bool()) {
+    if (__new_size < size()) 
+      erase(begin() + difference_type(__new_size), end());
+    else
+      insert(end(), __new_size - size(), __x);
+  }
+  void clear() { erase(begin(), end()); }
+};
+
+#ifdef __SGI_STL_VECBOOL_TEMPLATE
+
+typedef vector<bool, alloc> bit_vector;
+
+#else /* __SGI_STL_VECBOOL_TEMPLATE */
+
+inline bool 
+operator==(const bit_vector& __x, const bit_vector& __y)
+{
+  return (__x.size() == __y.size() && 
+          equal(__x.begin(), __x.end(), __y.begin()));
+}
+
+inline bool 
+operator<(const bit_vector& __x, const bit_vector& __y)
+{
+  return lexicographical_compare(__x.begin(), __x.end(), 
+                                 __y.begin(), __y.end());
+}
+
+#endif /* __SGI_STL_VECBOOL_TEMPLATE */
+
+#undef __SGI_STL_VECBOOL_TEMPLATE
+#undef __BVECTOR
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1174
+#pragma reset woff 1375
+#endif
+
+__STL_END_NAMESPACE 
+
+#endif /* __SGI_STL_INTERNAL_BVECTOR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_config.h b/gnu/egcs/libstdc++/stl/stl_config.h
new file mode 100644
index 00000000000..f9295f1f1dd
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_config.h
@@ -0,0 +1,354 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ * Copyright (c) 1997
+ * Silicon Graphics
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef __STL_CONFIG_H
+# define __STL_CONFIG_H
+
+// Flags:
+// * __STL_NO_BOOL: defined if the compiler doesn't have bool as a builtin
+//   type.
+// * __STL_HAS_WCHAR_T: defined if the compier has wchar_t as a builtin type.
+// * __STL_NO_DRAND48: defined if the compiler doesn't have the drand48
+//   function.
+// * __STL_STATIC_TEMPLATE_MEMBER_BUG: defined if the compiler can't handle
+//   static members of template classes.
+// * __STL_CLASS_PARTIAL_SPECIALIZATION: defined if the compiler supports
+//   partial specialization of template classes.
+// * __STL_PARTIAL_SPECIALIZATION_SYNTAX: defined if the compiler
+//   supports partial specialization syntax for full specialization of
+//   class templates.  (Even if it doesn't actually support partial
+//   specialization itself.)
+// * __STL_FUNCTION_TMPL_PARTIAL_ORDER: defined if the compiler supports
+//   partial ordering of function templates.  (a.k.a partial specialization
+//   of function templates.)
+// * __STL_MEMBER_TEMPLATES: defined if the compiler supports template
+//   member functions of classes.
+// * __STL_MEMBER_TEMPLATE_CLASSES: defined if the compiler supports
+//   nested classes that are member templates of other classes.
+// * __STL_EXPLICIT_FUNCTION_TMPL_ARGS: defined if the compiler
+//   supports calling a function template by providing its template
+//   arguments explicitly.
+// * __STL_LIMITED_DEFAULT_TEMPLATES: defined if the compiler is unable
+//   to handle default template parameters that depend on previous template
+//   parameters.
+// * __STL_NON_TYPE_TMPL_PARAM_BUG: defined if the compiler has trouble with
+//   function template argument deduction for non-type template parameters.
+// * __SGI_STL_NO_ARROW_OPERATOR: defined if the compiler is unable
+//   to support the -> operator for iterators.
+// * __STL_USE_EXCEPTIONS: defined if the compiler (in the current compilation
+//   mode) supports exceptions.
+// * __STL_USE_NAMESPACES: defined if the compiler has the necessary
+//   support for namespaces.
+// * __STL_NO_EXCEPTION_HEADER: defined if the compiler does not have a
+//   standard-conforming header <exception>.
+// * __STL_SGI_THREADS: defined if this is being compiled for an SGI IRIX
+//   system in multithreaded mode, using native SGI threads instead of
+//   pthreads.
+// * __STL_WIN32THREADS: defined if this is being compiled on a WIN32
+//   compiler in multithreaded mode.
+// * __STL_LONG_LONG if the compiler has long long and unsigned long long
+//   types.  (They're not in the C++ standard, but they are expected to be
+//   included in the forthcoming C9X standard.)
+
+
+// User-settable macros that control compilation:
+// * __STL_USE_SGI_ALLOCATORS: if defined, then the STL will use older
+//   SGI-style allocators, instead of standard-conforming allocators,
+//   even if the compiler supports all of the language features needed
+//   for standard-conforming allocators.
+// * __STL_NO_NAMESPACES: if defined, don't put the library in namespace
+//   std, even if the compiler supports namespaces.
+// * __STL_ASSERTIONS: if defined, then enable runtime checking through the
+//   __stl_assert macro.
+// * _PTHREADS: if defined, use Posix threads for multithreading support.
+// * _NOTHREADS: if defined, don't use any multithreading support.
+
+
+// Other macros defined by this file:
+
+// * bool, true, and false, if __STL_NO_BOOL is defined.
+// * typename, as a null macro if it's not already a keyword.
+// * explicit, as a null macro if it's not already a keyword.
+// * namespace-related macros (__STD, __STL_BEGIN_NAMESPACE, etc.)
+// * exception-related macros (__STL_TRY, __STL_UNWIND, etc.)
+// * __stl_assert, either as a test or as a null macro, depending on
+//   whether or not __STL_ASSERTIONS is defined.
+
+#ifdef _PTHREADS
+#   define __STL_PTHREADS
+#endif
+#ifdef _SOLTHREADS
+#   define __STL_SOLTHREADS
+#endif
+
+# if defined(__sgi) && !defined(__GNUC__)
+#   if !defined(_BOOL)
+#     define __STL_NO_BOOL
+#   endif
+#   if defined(_WCHAR_T_IS_KEYWORD)
+#     define __STL_HAS_WCHAR_T
+#   endif
+#   if !defined(_TYPENAME_IS_KEYWORD)
+#     define __STL_NEED_TYPENAME
+#   endif
+#   ifdef _PARTIAL_SPECIALIZATION_OF_CLASS_TEMPLATES
+#     define __STL_CLASS_PARTIAL_SPECIALIZATION
+#   endif
+#   ifdef _MEMBER_TEMPLATES
+#     define __STL_MEMBER_TEMPLATES
+#     define __STL_MEMBER_TEMPLATE_CLASSES
+#   endif
+#   if defined(_MEMBER_TEMPLATE_KEYWORD)
+#     define __STL_MEMBER_TEMPLATE_KEYWORD
+#   endif
+#   if (_COMPILER_VERSION >= 730) && defined(_MIPS_SIM) && _MIPS_SIM != _ABIO32
+#     define __STL_MEMBER_TEMPLATE_KEYWORD
+#   endif
+#   if !defined(_EXPLICIT_IS_KEYWORD)
+#     define __STL_NEED_EXPLICIT
+#   endif
+#   ifdef __EXCEPTIONS
+#     define __STL_USE_EXCEPTIONS
+#   endif
+#   if (_COMPILER_VERSION >= 721) && defined(_NAMESPACES)
+#     define __STL_HAS_NAMESPACES
+#   endif
+#   if (_COMPILER_VERSION < 721)
+#     define __STL_NO_EXCEPTION_HEADER
+#   endif
+#   if !defined(_NOTHREADS) && !defined(__STL_PTHREADS)
+#     define __STL_SGI_THREADS
+#   endif
+#   if defined(_LONGLONG) && defined(_SGIAPI) && _SGIAPI
+#     define __STL_LONG_LONG
+#   endif
+# endif
+
+# ifdef __GNUC__
+#   include <_G_config.h>
+#   define __STL_HAS_WCHAR_T
+#   if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 8)
+#     define __STL_STATIC_TEMPLATE_MEMBER_BUG
+#     define __STL_NEED_TYPENAME
+#     define __STL_NEED_EXPLICIT
+#   else
+#     define __STL_CLASS_PARTIAL_SPECIALIZATION
+#     define __STL_FUNCTION_TMPL_PARTIAL_ORDER
+#     define __STL_MEMBER_TEMPLATES
+#     define __STL_MEMBER_TEMPLATE_CLASSES
+#     define __STL_EXPLICIT_FUNCTION_TMPL_ARGS
+#     define __STL_HAS_NAMESPACES
+#     define __STL_NO_NAMESPACES
+#     define __SGI_STL_USE_AUTO_PTR_CONVERSIONS
+#     define __STL_USE_NAMESPACES
+#   endif
+    /* glibc pre 2.0 is very buggy. We have to disable thread for it.
+       It should be upgraded to glibc 2.0 or later. */
+#   if !defined(_NOTHREADS) && __GLIBC__ >= 2 && defined(_G_USING_THUNKS)
+#     define __STL_PTHREADS
+#     ifdef __STRICT_ANSI__
+        /* Work around a bug in the glibc 2.0.x pthread.h.  */
+#       define sigset_t __sigset_t
+#     endif
+#   endif
+#   ifdef __EXCEPTIONS
+#     define __STL_USE_EXCEPTIONS
+#   endif
+#   ifndef __STRICT_ANSI__
+#     define __STL_LONG_LONG
+#   endif
+# endif
+
+# if defined(__SUNPRO_CC)
+#   define __STL_NO_BOOL
+#   define __STL_NEED_TYPENAME
+#   define __STL_NEED_EXPLICIT
+#   define __STL_USE_EXCEPTIONS
+# endif
+
+# if defined(__COMO__)
+#   define __STL_MEMBER_TEMPLATES
+#   define __STL_MEMBER_TEMPLATE_CLASSES
+#   define __STL_CLASS_PARTIAL_SPECIALIZATION
+#   define __STL_USE_EXCEPTIONS
+#   define __STL_HAS_NAMESPACES
+# endif
+
+# if defined(__MINGW32__)
+#   define __STL_NO_DRAND48
+# endif
+
+# if defined(__CYGWIN__)
+#   define __STL_NO_DRAND48
+# endif
+
+# if defined(_MSC_VER)
+#   define __STL_NO_DRAND48
+#   define __STL_NEED_TYPENAME
+#   if _MSC_VER < 1100  /* 1000 is version 4.0, 1100 is 5.0, 1200 is 6.0. */
+#     define __STL_NEED_EXPLICIT
+#     define __STL_NO_BOOL
+#     if  _MSC_VER > 1000
+#       include <yvals.h>
+#       define __STL_DONT_USE_BOOL_TYPEDEF
+#     endif
+#   endif
+#   define __STL_NON_TYPE_TMPL_PARAM_BUG
+#   define __SGI_STL_NO_ARROW_OPERATOR
+#   ifdef _CPPUNWIND
+#     define __STL_USE_EXCEPTIONS
+#   endif
+#   ifdef _MT
+#     define __STL_WIN32THREADS
+#   endif
+#   if _MSC_VER >= 1200
+#     define __STL_PARTIAL_SPECIALIZATION_SYNTAX
+#     define __STL_HAS_NAMESPACES
+#     define __STL_NO_NAMESPACES
+#   endif
+# endif
+
+# if defined(__BORLANDC__)
+#   define __STL_NO_DRAND48
+#   define __STL_NEED_TYPENAME
+#   define __STL_LIMITED_DEFAULT_TEMPLATES
+#   define __SGI_STL_NO_ARROW_OPERATOR
+#   define __STL_NON_TYPE_TMPL_PARAM_BUG
+#   ifdef _CPPUNWIND
+#     define __STL_USE_EXCEPTIONS
+#   endif
+#   ifdef __MT__
+#     define __STL_WIN32THREADS
+#   endif
+# endif
+
+# if defined(__STL_NO_BOOL) && !defined(__STL_DONT_USE_BOOL_TYPEDEF)
+    typedef int bool;
+#   define true 1
+#   define false 0
+# endif
+
+# ifdef __STL_NEED_TYPENAME
+#   define typename
+# endif
+
+# ifdef __STL_MEMBER_TEMPLATE_KEYWORD
+#   define __STL_TEMPLATE template
+# else
+#   define __STL_TEMPLATE
+# endif
+
+# ifdef __STL_NEED_EXPLICIT
+#   define explicit
+# endif
+
+# ifdef __STL_EXPLICIT_FUNCTION_TMPL_ARGS
+#   define __STL_NULL_TMPL_ARGS <>
+# else
+#   define __STL_NULL_TMPL_ARGS
+# endif
+
+# if defined(__STL_CLASS_PARTIAL_SPECIALIZATION) \
+     || defined (__STL_PARTIAL_SPECIALIZATION_SYNTAX)
+#   define __STL_TEMPLATE_NULL template<>
+# else
+#   define __STL_TEMPLATE_NULL
+# endif
+
+// Use standard-conforming allocators if we have the necessary language
+// features.  __STL_USE_SGI_ALLOCATORS is a hook so that users can
+// disable new-style allocators, and continue to use the same kind of
+// allocators as before, without having to edit library headers.
+# if defined(__STL_CLASS_PARTIAL_SPECIALIZATION) && \
+     defined(__STL_MEMBER_TEMPLATES) && \
+     defined(__STL_MEMBER_TEMPLATE_CLASSES) && \
+    !defined(__STL_NO_BOOL) && \
+    !defined(__STL_NON_TYPE_TMPL_PARAM_BUG) && \
+    !defined(__STL_LIMITED_DEFAULT_TEMPLATES) && \
+    !defined(__STL_USE_SGI_ALLOCATORS)
+#   define __STL_USE_STD_ALLOCATORS
+# endif
+
+# ifndef __STL_DEFAULT_ALLOCATOR
+#   ifdef __STL_USE_STD_ALLOCATORS
+#     define __STL_DEFAULT_ALLOCATOR(T) allocator<T>
+#   else
+#     define __STL_DEFAULT_ALLOCATOR(T) alloc
+#   endif
+# endif
+
+// __STL_NO_NAMESPACES is a hook so that users can disable namespaces
+// without having to edit library headers.
+# if defined(__STL_HAS_NAMESPACES) && !defined(__STL_NO_NAMESPACES)
+#   define __STD std
+#   define __STL_BEGIN_NAMESPACE namespace std {
+#   define __STL_END_NAMESPACE }
+#   define __STL_USE_NAMESPACE_FOR_RELOPS
+#   define __STL_BEGIN_RELOPS_NAMESPACE namespace std {
+#   define __STL_END_RELOPS_NAMESPACE }
+#   define __STD_RELOPS std
+#   define __STL_USE_NAMESPACES
+# else
+#   define __STD
+#   define __STL_BEGIN_NAMESPACE
+#   define __STL_END_NAMESPACE
+#   undef  __STL_USE_NAMESPACE_FOR_RELOPS
+#   define __STL_BEGIN_RELOPS_NAMESPACE
+#   define __STL_END_RELOPS_NAMESPACE
+#   define __STD_RELOPS
+#   undef  __STL_USE_NAMESPACES
+# endif
+
+# ifdef __STL_USE_EXCEPTIONS
+#   define __STL_TRY try
+#   define __STL_CATCH_ALL catch(...)
+#   define __STL_THROW(x) throw x
+#   define __STL_RETHROW throw
+#   define __STL_NOTHROW throw()
+#   define __STL_UNWIND(action) catch(...) { action; throw; }
+# else
+#   define __STL_TRY
+#   define __STL_CATCH_ALL if (false)
+#   define __STL_THROW(x)
+#   define __STL_RETHROW
+#   define __STL_NOTHROW
+#   define __STL_UNWIND(action)
+# endif
+
+#ifdef __STL_ASSERTIONS
+# include <stdio.h>
+# define __stl_assert(expr) \
+    if (!(expr)) { fprintf(stderr, "%s:%d STL assertion failure: %s\n", \
+			  __FILE__, __LINE__, # expr); abort(); }
+#else
+# define __stl_assert(expr)
+#endif
+
+#endif /* __STL_CONFIG_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_construct.h b/gnu/egcs/libstdc++/stl/stl_construct.h
new file mode 100644
index 00000000000..761784d57da
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_construct.h
@@ -0,0 +1,90 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_CONSTRUCT_H
+#define __SGI_STL_INTERNAL_CONSTRUCT_H
+
+#include <new.h>
+
+__STL_BEGIN_NAMESPACE
+
+// construct and destroy.  These functions are not part of the C++ standard,
+// and are provided for backward compatibility with the HP STL.
+
+template <class _Tp>
+inline void destroy(_Tp* __pointer) {
+  __pointer->~_Tp();
+}
+
+template <class _T1, class _T2>
+inline void construct(_T1* __p, const _T2& __value) {
+  new (__p) _T1(__value);
+}
+
+template <class _T1>
+inline void construct(_T1* __p) {
+  new (__p) _T1();
+}
+
+template <class _ForwardIterator>
+inline void
+__destroy_aux(_ForwardIterator __first, _ForwardIterator __last, __false_type)
+{
+  for ( ; __first != __last; ++__first)
+    destroy(&*__first);
+}
+
+template <class _ForwardIterator>
+inline void __destroy_aux(_ForwardIterator, _ForwardIterator, __true_type) {}
+
+template <class _ForwardIterator, class _Tp>
+inline void
+__destroy(_ForwardIterator __first, _ForwardIterator __last, _Tp*)
+{
+  typedef typename __type_traits<_Tp>::has_trivial_destructor
+          _Trivial_destructor;
+  __destroy_aux(__first, __last, _Trivial_destructor());
+}
+
+template <class _ForwardIterator>
+inline void destroy(_ForwardIterator __first, _ForwardIterator __last) {
+  __destroy(__first, __last, __VALUE_TYPE(__first));
+}
+
+inline void destroy(char*, char*) {}
+inline void destroy(wchar_t*, wchar_t*) {}
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_CONSTRUCT_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_deque.h b/gnu/egcs/libstdc++/stl/stl_deque.h
new file mode 100644
index 00000000000..48a4c76d55a
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_deque.h
@@ -0,0 +1,1698 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_DEQUE_H
+#define __SGI_STL_INTERNAL_DEQUE_H
+
+/* Class invariants:
+ *  For any nonsingular iterator i:
+ *    i.node is the address of an element in the map array.  The
+ *      contents of i.node is a pointer to the beginning of a node.
+ *    i.first == *(i.node) 
+ *    i.last  == i.first + node_size
+ *    i.cur is a pointer in the range [i.first, i.last).  NOTE:
+ *      the implication of this is that i.cur is always a dereferenceable
+ *      pointer, even if i is a past-the-end iterator.
+ *  Start and Finish are always nonsingular iterators.  NOTE: this means
+ *    that an empty deque must have one node, and that a deque
+ *    with N elements, where N is the buffer size, must have two nodes.
+ *  For every node other than start.node and finish.node, every element
+ *    in the node is an initialized object.  If start.node == finish.node,
+ *    then [start.cur, finish.cur) are initialized objects, and
+ *    the elements outside that range are uninitialized storage.  Otherwise,
+ *    [start.cur, start.last) and [finish.first, finish.cur) are initialized
+ *    objects, and [start.first, start.cur) and [finish.cur, finish.last)
+ *    are uninitialized storage.
+ *  [map, map + map_size) is a valid, non-empty range.  
+ *  [start.node, finish.node] is a valid range contained within 
+ *    [map, map + map_size).  
+ *  A pointer in the range [map, map + map_size) points to an allocated node
+ *    if and only if the pointer is in the range [start.node, finish.node].
+ */
+
+
+/*
+ * In previous versions of deque, node_size was fixed by the 
+ * implementation.  In this version, however, users can select
+ * the node size.  Deque has three template parameters; the third,
+ * a number of type size_t, is the number of elements per node.
+ * If the third template parameter is 0 (which is the default), 
+ * then deque will use a default node size.
+ *
+ * The only reason for using an alternate node size is if your application
+ * requires a different performance tradeoff than the default.  If,
+ * for example, your program contains many deques each of which contains
+ * only a few elements, then you might want to save memory (possibly
+ * by sacrificing some speed) by using smaller nodes.
+ *
+ * Unfortunately, some compilers have trouble with non-type template 
+ * parameters; stl_config.h defines __STL_NON_TYPE_TMPL_PARAM_BUG if
+ * that is the case.  If your compiler is one of them, then you will
+ * not be able to use alternate node sizes; you will have to use the
+ * default value.
+ */
+
+__STL_BEGIN_NAMESPACE 
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1174
+#pragma set woff 1375
+#endif
+
+// Note: this function is simply a kludge to work around several compilers'
+//  bugs in handling constant expressions.
+inline size_t
+__deque_buf_size(size_t __n, size_t __size)
+{
+  return __n != 0 ? __n : (__size < 512 ? size_t(512 / __size) : size_t(1));
+}
+
+#ifndef __STL_NON_TYPE_TMPL_PARAM_BUG
+template <class _Tp, class _Ref, class _Ptr, size_t __bufsiz>
+struct _Deque_iterator {
+  typedef _Deque_iterator<_Tp,_Tp&,_Tp*,__bufsiz>             iterator;
+  typedef _Deque_iterator<_Tp,const _Tp&,const _Tp*,__bufsiz> const_iterator;
+  static size_t 
+    _S_buffer_size() { return __deque_buf_size(__bufsiz, sizeof(_Tp)); }
+#else /* __STL_NON_TYPE_TMPL_PARAM_BUG */
+template <class _Tp, class _Ref, class _Ptr>
+struct _Deque_iterator {
+  typedef _Deque_iterator<_Tp, _Tp&, _Tp*>             iterator;
+  typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
+  static size_t 
+    _S_buffer_size() { return __deque_buf_size(0, sizeof(_Tp)); }
+#endif
+
+  typedef random_access_iterator_tag iterator_category;
+  typedef _Tp value_type;
+  typedef _Ptr pointer;
+  typedef _Ref reference;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef _Tp** _Map_pointer;
+
+  typedef _Deque_iterator _Self;
+
+  _Tp* _M_cur;
+  _Tp* _M_first;
+  _Tp* _M_last;
+  _Map_pointer _M_node;
+
+  _Deque_iterator(_Tp* __x, _Map_pointer __y) 
+    : _M_cur(__x), _M_first(*__y),
+      _M_last(*__y + _S_buffer_size()), _M_node(__y) {}
+  _Deque_iterator() : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) {}
+  _Deque_iterator(const iterator& __x)
+    : _M_cur(__x._M_cur), _M_first(__x._M_first), 
+      _M_last(__x._M_last), _M_node(__x._M_node) {}
+
+  reference operator*() const { return *_M_cur; }
+#ifndef __SGI_STL_NO_ARROW_OPERATOR
+  pointer operator->() const { return _M_cur; }
+#endif /* __SGI_STL_NO_ARROW_OPERATOR */
+
+  difference_type operator-(const _Self& __x) const {
+    return difference_type(_S_buffer_size()) * (_M_node - __x._M_node - 1) +
+      (_M_cur - _M_first) + (__x._M_last - __x._M_cur);
+  }
+
+  _Self& operator++() {
+    ++_M_cur;
+    if (_M_cur == _M_last) {
+      _M_set_node(_M_node + 1);
+      _M_cur = _M_first;
+    }
+    return *this; 
+  }
+  _Self operator++(int)  {
+    _Self __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
+
+  _Self& operator--() {
+    if (_M_cur == _M_first) {
+      _M_set_node(_M_node - 1);
+      _M_cur = _M_last;
+    }
+    --_M_cur;
+    return *this;
+  }
+  _Self operator--(int) {
+    _Self __tmp = *this;
+    --*this;
+    return __tmp;
+  }
+
+  _Self& operator+=(difference_type __n)
+  {
+    difference_type __offset = __n + (_M_cur - _M_first);
+    if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
+      _M_cur += __n;
+    else {
+      difference_type __node_offset =
+        __offset > 0 ? __offset / difference_type(_S_buffer_size())
+                   : -difference_type((-__offset - 1) / _S_buffer_size()) - 1;
+      _M_set_node(_M_node + __node_offset);
+      _M_cur = _M_first + 
+        (__offset - __node_offset * difference_type(_S_buffer_size()));
+    }
+    return *this;
+  }
+
+  _Self operator+(difference_type __n) const
+  {
+    _Self __tmp = *this;
+    return __tmp += __n;
+  }
+
+  _Self& operator-=(difference_type __n) { return *this += -__n; }
+ 
+  _Self operator-(difference_type __n) const {
+    _Self __tmp = *this;
+    return __tmp -= __n;
+  }
+
+  reference operator[](difference_type __n) const { return *(*this + __n); }
+
+  bool operator==(const _Self& __x) const { return _M_cur == __x._M_cur; }
+  bool operator!=(const _Self& __x) const { return !(*this == __x); }
+  bool operator<(const _Self& __x) const {
+    return (_M_node == __x._M_node) ? 
+      (_M_cur < __x._M_cur) : (_M_node < __x._M_node);
+  }
+
+  void _M_set_node(_Map_pointer __new_node) {
+    _M_node = __new_node;
+    _M_first = *__new_node;
+    _M_last = _M_first + difference_type(_S_buffer_size());
+  }
+};
+
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+#ifndef __STL_NON_TYPE_TMPL_PARAM_BUG
+
+template <class _Tp, class _Ref, class _Ptr, size_t __bufsiz>
+inline random_access_iterator_tag
+iterator_category(const _Deque_iterator<_Tp,_Ref,_Ptr,__bufsiz>&) {
+  return random_access_iterator_tag();
+}
+
+template <class _Tp, class _Ref, class _Ptr, size_t __bufsiz>
+inline _Tp*
+value_type(const _Deque_iterator<_Tp,_Ref,_Ptr,__bufsiz>&) {
+  return 0;
+}
+
+template <class _Tp, class _Ref, class _Ptr, size_t __bufsiz>
+inline ptrdiff_t*
+distance_type(const _Deque_iterator<_Tp,_Ref,_Ptr,__bufsiz>&) {
+  return 0;
+}
+
+#else /* __STL_NON_TYPE_TMPL_PARAM_BUG */
+
+template <class _Tp, class _Ref, class _Ptr>
+inline random_access_iterator_tag
+iterator_category(const _Deque_iterator<_Tp,_Ref,_Ptr>&)
+{
+  return random_access_iterator_tag();
+}
+
+template <class _Tp, class _Ref, class _Ptr>
+inline _Tp*
+value_type(const _Deque_iterator<_Tp,_Ref,_Ptr>&) { return 0; }
+
+template <class _Tp, class _Ref, class _Ptr>
+inline ptrdiff_t*
+distance_type(const _Deque_iterator<_Tp,_Ref,_Ptr>&) {
+  return 0;
+}
+
+#endif /* __STL_NON_TYPE_TMPL_PARAM_BUG */
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+// Deque base class.  It has two purposes.  First, its constructor
+//  and destructor allocate (but don't initialize) storage.  This makes
+//  exception safety easier.  Second, the base class encapsulates all of
+//  the differences between SGI-style allocators and standard-conforming
+//  allocators.
+
+#ifdef __STL_USE_STD_ALLOCATORS
+
+// Base class for ordinary allocators.
+template <class _Tp, class _Alloc, size_t __bufsiz, bool __is_static>
+class _Deque_alloc_base {
+public:
+  typedef typename _Alloc_traits<_Tp,_Alloc>::allocator_type allocator_type;
+  allocator_type get_allocator() const { return node_allocator; }
+
+  _Deque_alloc_base(const allocator_type& __a)
+    : node_allocator(__a), map_allocator(__a), _M_map(0), _M_map_size(0)
+  {}
+  
+protected:
+  typedef typename _Alloc_traits<_Tp*, _Alloc>::allocator_type
+          map_allocator_type;
+
+  allocator_type node_allocator;
+  map_allocator_type map_allocator;
+
+  _Tp* _M_allocate_node() {
+    return node_allocator.allocate(__deque_buf_size(__bufsiz,sizeof(_Tp)));
+  }
+  void _M_deallocate_node(_Tp* __p) {
+    node_allocator.deallocate(__p, __deque_buf_size(__bufsiz,sizeof(_Tp)));
+  }
+  _Tp** _M_allocate_map(size_t __n) 
+    { return map_allocator.allocate(__n); }
+  void _M_deallocate_map(_Tp** __p, size_t __n) 
+    { map_allocator.deallocate(__p, __n); }
+
+  _Tp** _M_map;
+  size_t _M_map_size;
+};
+
+// Specialization for instanceless allocators.
+template <class _Tp, class _Alloc, size_t __bufsiz>
+class _Deque_alloc_base<_Tp, _Alloc, __bufsiz, true>
+{
+public:
+  typedef typename _Alloc_traits<_Tp,_Alloc>::allocator_type allocator_type;
+  allocator_type get_allocator() const { return allocator_type(); }
+
+  _Deque_alloc_base(const allocator_type&) : _M_map(0), _M_map_size(0) {}
+  
+protected:
+  typedef typename _Alloc_traits<_Tp, _Alloc>::_Alloc_type _Node_alloc_type;
+  typedef typename _Alloc_traits<_Tp*, _Alloc>::_Alloc_type _Map_alloc_type;
+
+  _Tp* _M_allocate_node()
+    { return _Node_alloc_type::allocate(__deque_buf_size(__bufsiz, 
+                                                         sizeof(_Tp))); }
+  void _M_deallocate_node(_Tp* __p)
+    { _Node_alloc_type::deallocate(__p, __deque_buf_size(__bufsiz, 
+                                                         sizeof(_Tp))); }
+  _Tp** _M_allocate_map(size_t __n) 
+    { return _Map_alloc_type::allocate(__n); }
+  void _M_deallocate_map(_Tp** __p, size_t __n) 
+    { _Map_alloc_type::deallocate(__p, __n); }
+
+  _Tp** _M_map;
+  size_t _M_map_size;
+};
+
+template <class _Tp, class _Alloc, size_t __bufsiz>
+class _Deque_base
+  : public _Deque_alloc_base<_Tp,_Alloc,__bufsiz, 
+                              _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
+{
+public:
+  typedef _Deque_alloc_base<_Tp,_Alloc,__bufsiz,
+                             _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
+          _Base;
+  typedef typename _Base::allocator_type allocator_type;
+  typedef _Deque_iterator<_Tp,_Tp&,_Tp*,__bufsiz>              iterator;
+  typedef _Deque_iterator<_Tp,const _Tp&,const _Tp&, __bufsiz> const_iterator;
+
+  _Deque_base(const allocator_type& __a, size_t __num_elements)
+    : _Base(__a), _M_start(), _M_finish()
+    { _M_initialize_map(__num_elements); }
+  _Deque_base(const allocator_type& __a) 
+    : _Base(__a), _M_start(), _M_finish() {}
+  ~_Deque_base();    
+
+protected:
+  void _M_initialize_map(size_t);
+  void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish);
+  void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish);
+  enum { _S_initial_map_size = 8 };
+
+protected:
+  iterator _M_start;
+  iterator _M_finish;
+};
+
+#else /* __STL_USE_STD_ALLOCATORS */
+
+template <class _Tp, class _Alloc, size_t __bufsiz>
+class _Deque_base {
+public:
+#ifndef __STL_NON_TYPE_TMPL_PARAM_BUG
+  typedef _Deque_iterator<_Tp,_Tp&,_Tp*,__bufsiz>              iterator;
+  typedef _Deque_iterator<_Tp,const _Tp&,const _Tp*, __bufsiz> const_iterator;
+#else /* __STL_NON_TYPE_TMPL_PARAM_BUG */
+  typedef _Deque_iterator<_Tp,_Tp&,_Tp*>                      iterator;
+  typedef _Deque_iterator<_Tp,const _Tp&,const _Tp*>          const_iterator;
+#endif /* __STL_NON_TYPE_TMPL_PARAM_BUG */
+
+  typedef _Alloc allocator_type;
+  allocator_type get_allocator() const { return allocator_type(); }
+
+  _Deque_base(const allocator_type&, size_t __num_elements)
+    : _M_map(0), _M_map_size(0),  _M_start(), _M_finish() {
+    _M_initialize_map(__num_elements);
+  }
+  _Deque_base(const allocator_type&)
+    : _M_map(0), _M_map_size(0),  _M_start(), _M_finish() {}
+  ~_Deque_base();    
+
+protected:
+  void _M_initialize_map(size_t);
+  void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish);
+  void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish);
+  enum { _S_initial_map_size = 8 };
+
+protected:
+  _Tp** _M_map;
+  size_t _M_map_size;  
+  iterator _M_start;
+  iterator _M_finish;
+
+  typedef simple_alloc<_Tp, _Alloc>  _Node_alloc_type;
+  typedef simple_alloc<_Tp*, _Alloc> _Map_alloc_type;
+
+  _Tp* _M_allocate_node()
+    { return _Node_alloc_type::allocate(__deque_buf_size(__bufsiz, 
+                                                         sizeof(_Tp))); }
+  void _M_deallocate_node(_Tp* __p)
+    { _Node_alloc_type::deallocate(__p, __deque_buf_size(__bufsiz, 
+                                                         sizeof(_Tp))); }
+  _Tp** _M_allocate_map(size_t __n) 
+    { return _Map_alloc_type::allocate(__n); }
+  void _M_deallocate_map(_Tp** __p, size_t __n) 
+    { _Map_alloc_type::deallocate(__p, __n); }
+};
+
+#endif /* __STL_USE_STD_ALLOCATORS */
+
+// Non-inline member functions from _Deque_base.
+
+template <class _Tp, class _Alloc, size_t __bufsiz>
+_Deque_base<_Tp,_Alloc,__bufsiz>::~_Deque_base() {
+  if (_M_map) {
+    _M_destroy_nodes(_M_start._M_node, _M_finish._M_node + 1);
+    _M_deallocate_map(_M_map, _M_map_size);
+  }
+}
+
+template <class _Tp, class _Alloc, size_t __bufsiz>
+void
+_Deque_base<_Tp,_Alloc,__bufsiz>::_M_initialize_map(size_t __num_elements)
+{
+  size_t __num_nodes = 
+    __num_elements / __deque_buf_size(__bufsiz, sizeof(_Tp)) + 1;
+
+  _M_map_size = max((size_t) _S_initial_map_size, __num_nodes + 2);
+  _M_map = _M_allocate_map(_M_map_size);
+
+  _Tp** __nstart = _M_map + (_M_map_size - __num_nodes) / 2;
+  _Tp** __nfinish = __nstart + __num_nodes;
+    
+  __STL_TRY {
+    _M_create_nodes(__nstart, __nfinish);
+  }
+  __STL_UNWIND((_M_deallocate_map(_M_map, _M_map_size), 
+                _M_map = 0, _M_map_size = 0));
+  _M_start._M_set_node(__nstart);
+  _M_finish._M_set_node(__nfinish - 1);
+  _M_start._M_cur = _M_start._M_first;
+  _M_finish._M_cur = _M_finish._M_first +
+               __num_elements % __deque_buf_size(__bufsiz, sizeof(_Tp));
+}
+
+template <class _Tp, class _Alloc, size_t __bufsiz>
+void
+_Deque_base<_Tp,_Alloc,__bufsiz>::_M_create_nodes(_Tp** __nstart,
+                                                  _Tp** __nfinish)
+{
+  _Tp** __cur;
+  __STL_TRY {
+    for (__cur = __nstart; __cur < __nfinish; ++__cur)
+      *__cur = _M_allocate_node();
+  }
+  __STL_UNWIND(_M_destroy_nodes(__nstart, __cur));
+}
+
+template <class _Tp, class _Alloc, size_t __bufsiz>
+void 
+_Deque_base<_Tp,_Alloc,__bufsiz>::_M_destroy_nodes(_Tp** __nstart,
+                                                   _Tp** __nfinish)
+{
+  for (_Tp** __n = __nstart; __n < __nfinish; ++__n)
+    _M_deallocate_node(*__n);
+}
+
+// See __deque_buf_size().  The only reason that the default value is 0
+//  is as a workaround for bugs in the way that some compilers handle
+//  constant expressions.
+template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp), 
+          size_t __bufsiz = 0> 
+class deque : protected _Deque_base<_Tp, _Alloc, __bufsiz> {
+  typedef _Deque_base<_Tp, _Alloc, __bufsiz> _Base;
+public:                         // Basic types
+  typedef _Tp value_type;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+
+  typedef typename _Base::allocator_type allocator_type;
+  allocator_type get_allocator() const { return _Base::get_allocator(); }
+
+public:                         // Iterators
+  typedef typename _Base::iterator       iterator;
+  typedef typename _Base::const_iterator const_iterator;
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+  typedef reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef reverse_iterator<iterator> reverse_iterator;
+#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+  typedef reverse_iterator<const_iterator, value_type, const_reference, 
+                           difference_type>  
+          const_reverse_iterator;
+  typedef reverse_iterator<iterator, value_type, reference, difference_type>
+          reverse_iterator; 
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+protected:                      // Internal typedefs
+  typedef pointer* _Map_pointer;
+  static size_t _S_buffer_size()
+    { return __deque_buf_size(__bufsiz, sizeof(_Tp)); }
+
+protected:
+#ifdef __STL_USE_NAMESPACES
+  using _Base::_M_initialize_map;
+  using _Base::_M_create_nodes;
+  using _Base::_M_destroy_nodes;
+  using _Base::_M_allocate_node;
+  using _Base::_M_deallocate_node;
+  using _Base::_M_allocate_map;
+  using _Base::_M_deallocate_map;
+
+  using _Base::_M_map;
+  using _Base::_M_map_size;
+  using _Base::_M_start;
+  using _Base::_M_finish;
+#endif /* __STL_USE_NAMESPACES */
+
+public:                         // Basic accessors
+  iterator begin() { return _M_start; }
+  iterator end() { return _M_finish; }
+  const_iterator begin() const { return _M_start; }
+  const_iterator end() const { return _M_finish; }
+
+  reverse_iterator rbegin() { return reverse_iterator(_M_finish); }
+  reverse_iterator rend() { return reverse_iterator(_M_start); }
+  const_reverse_iterator rbegin() const 
+    { return const_reverse_iterator(_M_finish); }
+  const_reverse_iterator rend() const 
+    { return const_reverse_iterator(_M_start); }
+
+  reference operator[](size_type __n)
+    { return _M_start[difference_type(__n)]; }
+  const_reference operator[](size_type __n) const 
+    { return _M_start[difference_type(__n)]; }
+
+  reference front() { return *_M_start; }
+  reference back() {
+    iterator __tmp = _M_finish;
+    --__tmp;
+    return *__tmp;
+  }
+  const_reference front() const { return *_M_start; }
+  const_reference back() const {
+    const_iterator __tmp = _M_finish;
+    --__tmp;
+    return *__tmp;
+  }
+
+  size_type size() const { return _M_finish - _M_start;; }
+  size_type max_size() const { return size_type(-1); }
+  bool empty() const { return _M_finish == _M_start; }
+
+public:                         // Constructor, destructor.
+  explicit deque(const allocator_type& __a = allocator_type()) 
+    : _Base(__a, 0) {}
+  deque(const deque& __x) : _Base(__x.get_allocator(), __x.size()) 
+    { uninitialized_copy(__x.begin(), __x.end(), _M_start); }
+  deque(size_type __n, const value_type& __value,
+        const allocator_type& __a = allocator_type()) : _Base(__a, __n)
+    { _M_fill_initialize(__value); }
+  explicit deque(size_type __n) : _Base(allocator_type(), __n)
+    { _M_fill_initialize(value_type()); }
+
+#ifdef __STL_MEMBER_TEMPLATES
+
+  // Check whether it's an integral type.  If so, it's not an iterator.
+  template <class _InputIterator>
+  deque(_InputIterator __first, _InputIterator __last,
+        const allocator_type& __a = allocator_type()) : _Base(__a) {
+    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
+    _M_initialize_dispatch(__first, __last, _Integral());
+  }
+
+  template <class _Integer>
+  void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) {
+    _M_initialize_map(__n);
+    _M_fill_initialize(__x);
+  }
+
+  template <class _InputIter>
+  void _M_initialize_dispatch(_InputIter __first, _InputIter __last,
+                              __false_type) {
+    _M_range_initialize(__first, __last, __ITERATOR_CATEGORY(__first));
+  }
+
+#else /* __STL_MEMBER_TEMPLATES */
+
+  deque(const value_type* __first, const value_type* __last,
+        const allocator_type& __a = allocator_type()) 
+    : _Base(__a, __last - __first)
+    { uninitialized_copy(__first, __last, _M_start); }
+  deque(const_iterator __first, const_iterator __last,
+        const allocator_type& __a = allocator_type()) 
+    : _Base(__a, __last - __first)
+    { uninitialized_copy(__first, __last, _M_start); }
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  ~deque() { destroy(_M_start, _M_finish); }
+
+  deque& operator= (const deque& __x) {
+    const size_type __len = size();
+    if (&__x != this) {
+      if (__len >= __x.size())
+        erase(copy(__x.begin(), __x.end(), _M_start), _M_finish);
+      else {
+        const_iterator __mid = __x.begin() + difference_type(__len);
+        copy(__x.begin(), __mid, _M_start);
+        insert(_M_finish, __mid, __x.end());
+      }
+    }
+    return *this;
+  }        
+
+  void swap(deque& __x) {
+    __STD::swap(_M_start, __x._M_start);
+    __STD::swap(_M_finish, __x._M_finish);
+    __STD::swap(_M_map, __x._M_map);
+    __STD::swap(_M_map_size, __x._M_map_size);
+  }
+
+public: 
+  // assign(), a generalized assignment member function.  Two
+  // versions: one that takes a count, and one that takes a range.
+  // The range version is a member template, so we dispatch on whether
+  // or not the type is an integer.
+
+  void assign(size_type __n, const _Tp& __val) {
+    if (__n > size()) {
+      fill(begin(), end(), __val);
+      insert(end(), __n - size(), __val);
+    }
+    else {
+      erase(begin() + __n, end());
+      fill(begin(), end(), __val);
+    }
+  }
+
+#ifdef __STL_MEMBER_TEMPLATES
+
+  template <class _InputIterator>
+  void assign(_InputIterator __first, _InputIterator __last) {
+    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
+    _M_assign_dispatch(__first, __last, _Integral());
+  }
+
+private:                        // helper functions for assign() 
+
+  template <class _Integer>
+  void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+    { assign((size_type) __n, (_Tp) __val); }
+
+  template <class _InputIterator>
+  void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+                          __false_type) {
+    _M_assign_aux(__first, __last, __ITERATOR_CATEGORY(__first));
+  }
+
+  template <class _InputIterator>
+  void _M_assign_aux(_InputIterator __first, _InputIterator __last,
+                     input_iterator_tag);
+
+  template <class _ForwardIterator>
+  void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+                     forward_iterator_tag) {
+    size_type __len = 0;
+    distance(__first, __last, __len);
+    if (__len > size()) {
+      _ForwardIterator __mid = __first;
+      advance(__mid, size());
+      copy(__first, __mid, begin());
+      insert(end(), __mid, __last);
+    }
+    else
+      erase(copy(__first, __last, begin()), end());
+  }
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+public:                         // push_* and pop_*
+  
+  void push_back(const value_type& __t) {
+    if (_M_finish._M_cur != _M_finish._M_last - 1) {
+      construct(_M_finish._M_cur, __t);
+      ++_M_finish._M_cur;
+    }
+    else
+      _M_push_back_aux(__t);
+  }
+
+  void push_back() {
+    if (_M_finish._M_cur != _M_finish._M_last - 1) {
+      construct(_M_finish._M_cur);
+      ++_M_finish._M_cur;
+    }
+    else
+      _M_push_back_aux();
+  }
+
+  void push_front(const value_type& __t) {
+    if (_M_start._M_cur != _M_start._M_first) {
+      construct(_M_start._M_cur - 1, __t);
+      --_M_start._M_cur;
+    }
+    else
+      _M_push_front_aux(__t);
+  }
+
+  void push_front() {
+    if (_M_start._M_cur != _M_start._M_first) {
+      construct(_M_start._M_cur - 1);
+      --_M_start._M_cur;
+    }
+    else
+      _M_push_front_aux();
+  }
+
+
+  void pop_back() {
+    if (_M_finish._M_cur != _M_finish._M_first) {
+      --_M_finish._M_cur;
+      destroy(_M_finish._M_cur);
+    }
+    else
+      _M_pop_back_aux();
+  }
+
+  void pop_front() {
+    if (_M_start._M_cur != _M_start._M_last - 1) {
+      destroy(_M_start._M_cur);
+      ++_M_start._M_cur;
+    }
+    else 
+      _M_pop_front_aux();
+  }
+
+public:                         // Insert
+
+  iterator insert(iterator position, const value_type& __x) {
+    if (position._M_cur == _M_start._M_cur) {
+      push_front(__x);
+      return _M_start;
+    }
+    else if (position._M_cur == _M_finish._M_cur) {
+      push_back(__x);
+      iterator __tmp = _M_finish;
+      --__tmp;
+      return __tmp;
+    }
+    else {
+      return _M_insert_aux(position, __x);
+    }
+  }
+
+  iterator insert(iterator __position)
+    { return insert(__position, value_type()); }
+
+  void insert(iterator __pos, size_type __n, const value_type& __x); 
+
+#ifdef __STL_MEMBER_TEMPLATES  
+
+  // Check whether it's an integral type.  If so, it's not an iterator.
+  template <class _InputIterator>
+  void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
+    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
+    _M_insert_dispatch(__pos, __first, __last, _Integral());
+  }
+
+  template <class _Integer>
+  void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
+                          __true_type) {
+    insert(__pos, (size_type) __n, (value_type) __x);
+  }
+
+  template <class _InputIterator>
+  void _M_insert_dispatch(iterator __pos,
+                          _InputIterator __first, _InputIterator __last,
+                          __false_type) {
+    insert(__pos, __first, __last, __ITERATOR_CATEGORY(__first));
+  }
+
+#else /* __STL_MEMBER_TEMPLATES */
+
+  void insert(iterator __pos,
+              const value_type* __first, const value_type* __last);
+  void insert(iterator __pos,
+              const_iterator __first, const_iterator __last);
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  void resize(size_type __new_size, const value_type& __x) {
+    const size_type __len = size();
+    if (__new_size < __len) 
+      erase(_M_start + __new_size, _M_finish);
+    else
+      insert(_M_finish, __new_size - __len, __x);
+  }
+
+  void resize(size_type new_size) { resize(new_size, value_type()); }
+
+public:                         // Erase
+  iterator erase(iterator __pos) {
+    iterator __next = __pos;
+    ++__next;
+    difference_type __index = __pos - _M_start;
+    if (__index < (size() >> 1)) {
+      copy_backward(_M_start, __pos, __next);
+      pop_front();
+    }
+    else {
+      copy(__next, _M_finish, __pos);
+      pop_back();
+    }
+    return _M_start + __index;
+  }
+
+  iterator erase(iterator __first, iterator __last);
+  void clear(); 
+
+protected:                        // Internal construction/destruction
+
+  void _M_fill_initialize(const value_type& __value);
+
+#ifdef __STL_MEMBER_TEMPLATES  
+
+  template <class _InputIterator>
+  void _M_range_initialize(_InputIterator __first, _InputIterator __last,
+                        input_iterator_tag);
+
+  template <class _ForwardIterator>
+  void _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
+                        forward_iterator_tag);
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+protected:                        // Internal push_* and pop_*
+
+  void _M_push_back_aux(const value_type&);
+  void _M_push_back_aux();
+  void _M_push_front_aux(const value_type&);
+  void _M_push_front_aux();
+  void _M_pop_back_aux();
+  void _M_pop_front_aux();
+
+protected:                        // Internal insert functions
+
+#ifdef __STL_MEMBER_TEMPLATES  
+
+  template <class _InputIterator>
+  void insert(iterator __pos, _InputIterator __first, _InputIterator __last,
+              input_iterator_tag);
+
+  template <class _ForwardIterator>
+  void insert(iterator __pos,
+              _ForwardIterator __first, _ForwardIterator __last,
+              forward_iterator_tag);
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  iterator _M_insert_aux(iterator __pos, const value_type& __x);
+  iterator _M_insert_aux(iterator __pos);
+  void _M_insert_aux(iterator __pos, size_type __n, const value_type& __x);
+
+#ifdef __STL_MEMBER_TEMPLATES  
+
+  template <class _ForwardIterator>
+  void _M_insert_aux(iterator __pos, 
+                     _ForwardIterator __first, _ForwardIterator __last,
+                     size_type __n);
+
+#else /* __STL_MEMBER_TEMPLATES */
+  
+  void _M_insert_aux(iterator __pos,
+                     const value_type* __first, const value_type* __last,
+                     size_type __n);
+
+  void _M_insert_aux(iterator __pos, 
+                     const_iterator __first, const_iterator __last,
+                     size_type __n);
+ 
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  iterator _M_reserve_elements_at_front(size_type __n) {
+    size_type __vacancies = _M_start._M_cur - _M_start._M_first;
+    if (__n > __vacancies) 
+      _M_new_elements_at_front(__n - __vacancies);
+    return _M_start - difference_type(__n);
+  }
+
+  iterator _M_reserve_elements_at_back(size_type __n) {
+    size_type __vacancies = (_M_finish._M_last - _M_finish._M_cur) - 1;
+    if (__n > __vacancies)
+      _M_new_elements_at_back(__n - __vacancies);
+    return _M_finish + difference_type(__n);
+  }
+
+  void _M_new_elements_at_front(size_type __new_elements);
+  void _M_new_elements_at_back(size_type __new_elements);
+
+protected:                      // Allocation of _M_map and nodes
+
+  // Makes sure the _M_map has space for new nodes.  Does not actually
+  //  add the nodes.  Can invalidate _M_map pointers.  (And consequently, 
+  //  deque iterators.)
+
+  void _M_reserve_map_at_back (size_type __nodes_to_add = 1) {
+    if (__nodes_to_add + 1 > _M_map_size - (_M_finish._M_node - _M_map))
+      _M_reallocate_map(__nodes_to_add, false);
+  }
+
+  void _M_reserve_map_at_front (size_type __nodes_to_add = 1) {
+    if (__nodes_to_add > size_type(_M_start._M_node - _M_map))
+      _M_reallocate_map(__nodes_to_add, true);
+  }
+
+  void _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front);
+ 
+#ifdef __STL_NON_TYPE_TMPL_PARAM_BUG
+public:
+  bool operator==(const deque<_Tp,_Alloc,0>& __x) const {
+    return size() == __x.size() && equal(begin(), end(), __x.begin());
+  }
+  bool operator!=(const deque<_Tp,_Alloc,0>& __x) const {
+    return size() != __x.size() || !equal(begin(), end(), __x.begin());
+  }
+  bool operator<(const deque<_Tp,_Alloc,0>& __x) const {
+    return lexicographical_compare(begin(), end(), __x.begin(), __x.end());
+  }
+#endif /* __STL_NON_TYPE_TMPL_PARAM_BUG */
+};
+
+// Non-inline member functions
+
+#ifdef __STL_MEMBER_TEMPLATES
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+template <class _InputIter>
+void deque<_Tp, _Alloc, __bufsize>
+  ::_M_assign_aux(_InputIter __first, _InputIter __last, input_iterator_tag)
+{
+  iterator __cur = begin();
+  for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
+    *__cur = *__first;
+  if (__first == __last)
+    erase(__cur, end());
+  else
+    insert(end(), __first, __last);
+}
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+void 
+deque<_Tp, _Alloc, __bufsize>::insert(iterator __pos,
+                                      size_type __n, const value_type& __x)
+{
+  if (__pos._M_cur == _M_start._M_cur) {
+    iterator __new_start = _M_reserve_elements_at_front(__n);
+    uninitialized_fill(__new_start, _M_start, __x);
+    _M_start = __new_start;
+  }
+  else if (__pos._M_cur == _M_finish._M_cur) {
+    iterator __new_finish = _M_reserve_elements_at_back(__n);
+    uninitialized_fill(_M_finish, __new_finish, __x);
+    _M_finish = __new_finish;
+  }
+  else 
+    _M_insert_aux(__pos, __n, __x);
+}
+
+#ifndef __STL_MEMBER_TEMPLATES  
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+void deque<_Tp, _Alloc, __bufsize>::insert(iterator __pos,
+                                           const value_type* __first,
+                                           const value_type* __last) {
+  size_type __n = __last - __first;
+  if (__pos._M_cur == _M_start._M_cur) {
+    iterator __new_start = _M_reserve_elements_at_front(__n);
+    __STL_TRY {
+      uninitialized_copy(__first, __last, __new_start);
+      _M_start = __new_start;
+    }
+    __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node));
+  }
+  else if (__pos._M_cur == _M_finish._M_cur) {
+    iterator __new_finish = _M_reserve_elements_at_back(__n);
+    __STL_TRY {
+      uninitialized_copy(__first, __last, _M_finish);
+      _M_finish = __new_finish;
+    }
+    __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1, 
+                                  __new_finish._M_node + 1));
+  }
+  else
+    _M_insert_aux(__pos, __first, __last, __n);
+}
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+void deque<_Tp,_Alloc,__bufsize>::insert(iterator __pos,
+                                         const_iterator __first,
+                                         const_iterator __last)
+{
+  size_type __n = __last - __first;
+  if (__pos._M_cur == _M_start._M_cur) {
+    iterator __new_start = _M_reserve_elements_at_front(__n);
+    __STL_TRY {
+      uninitialized_copy(__first, __last, __new_start);
+      _M_start = __new_start;
+    }
+    __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node));
+  }
+  else if (__pos._M_cur == _M_finish._M_cur) {
+    iterator __new_finish = _M_reserve_elements_at_back(__n);
+    __STL_TRY {
+      uninitialized_copy(__first, __last, _M_finish);
+      _M_finish = __new_finish;
+    }
+    __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1, 
+                 __new_finish._M_node + 1));
+  }
+  else
+    _M_insert_aux(__pos, __first, __last, __n);
+}
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+deque<_Tp,_Alloc,__bufsize>::iterator 
+deque<_Tp,_Alloc,__bufsize>::erase(iterator __first, iterator __last)
+{
+  if (__first == _M_start && __last == _M_finish) {
+    clear();
+    return _M_finish;
+  }
+  else {
+    difference_type __n = __last - __first;
+    difference_type __elems_before = __first - _M_start;
+    if (__elems_before < (size() - __n) / 2) {
+      copy_backward(_M_start, __first, __last);
+      iterator __new_start = _M_start + __n;
+      destroy(_M_start, __new_start);
+      _M_destroy_nodes(__new_start._M_node, _M_start._M_node);
+      _M_start = __new_start;
+    }
+    else {
+      copy(__last, _M_finish, __first);
+      iterator __new_finish = _M_finish - __n;
+      destroy(__new_finish, _M_finish);
+      _M_destroy_nodes(__new_finish._M_node + 1, _M_finish._M_node + 1);
+      _M_finish = __new_finish;
+    }
+    return _M_start + __elems_before;
+  }
+}
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+void deque<_Tp,_Alloc,__bufsize>::clear()
+{
+  for (_Map_pointer __node = _M_start._M_node + 1;
+       __node < _M_finish._M_node;
+       ++__node) {
+    destroy(*__node, *__node + _S_buffer_size());
+    _M_deallocate_node(*__node);
+  }
+
+  if (_M_start._M_node != _M_finish._M_node) {
+    destroy(_M_start._M_cur, _M_start._M_last);
+    destroy(_M_finish._M_first, _M_finish._M_cur);
+    _M_deallocate_node(_M_finish._M_first);
+  }
+  else
+    destroy(_M_start._M_cur, _M_finish._M_cur);
+
+  _M_finish = _M_start;
+}
+
+// Precondition: _M_start and _M_finish have already been initialized,
+// but none of the deque's elements have yet been constructed.
+template <class _Tp, class _Alloc, size_t __bufsize>
+void 
+deque<_Tp,_Alloc,__bufsize>::_M_fill_initialize(const value_type& __value) {
+  _Map_pointer __cur;
+  __STL_TRY {
+    for (__cur = _M_start._M_node; __cur < _M_finish._M_node; ++__cur)
+      uninitialized_fill(*__cur, *__cur + _S_buffer_size(), __value);
+    uninitialized_fill(_M_finish._M_first, _M_finish._M_cur, __value);
+  }
+  __STL_UNWIND(destroy(_M_start, iterator(*__cur, __cur)));
+}
+
+#ifdef __STL_MEMBER_TEMPLATES  
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+template <class _InputIterator>
+void
+deque<_Tp,_Alloc,__bufsize>::_M_range_initialize(_InputIterator __first,
+                                                 _InputIterator __last,
+                                                 input_iterator_tag)
+{
+  _M_initialize_map(0);
+  for ( ; __first != __last; ++__first)
+    push_back(*__first);
+}
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+template <class _ForwardIterator>
+void
+deque<_Tp,_Alloc,__bufsize>::_M_range_initialize(_ForwardIterator __first,
+                                                 _ForwardIterator __last,
+                                                 forward_iterator_tag)
+{
+  size_type __n = 0;
+  distance(__first, __last, __n);
+  _M_initialize_map(__n);
+
+  _Map_pointer __cur_node;
+  __STL_TRY {
+    for (__cur_node = _M_start._M_node; 
+         __cur_node < _M_finish._M_node; 
+	 ++__cur_node) {
+      _ForwardIterator __mid = __first;
+      advance(__mid, _S_buffer_size());
+      uninitialized_copy(__first, __mid, *__cur_node);
+      __first = __mid;
+    }
+    uninitialized_copy(__first, __last, _M_finish._M_first);
+  }
+  __STL_UNWIND(destroy(_M_start, iterator(*__cur_node, __cur_node)));
+}
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+// Called only if _M_finish._M_cur == _M_finish._M_last - 1.
+template <class _Tp, class _Alloc, size_t __bufsize>
+void
+deque<_Tp,_Alloc,__bufsize>::_M_push_back_aux(const value_type& __t)
+{
+  value_type __t_copy = __t;
+  _M_reserve_map_at_back();
+  *(_M_finish._M_node + 1) = _M_allocate_node();
+  __STL_TRY {
+    construct(_M_finish._M_cur, __t_copy);
+    _M_finish._M_set_node(_M_finish._M_node + 1);
+    _M_finish._M_cur = _M_finish._M_first;
+  }
+  __STL_UNWIND(_M_deallocate_node(*(_M_finish._M_node + 1)));
+}
+
+// Called only if _M_finish._M_cur == _M_finish._M_last - 1.
+template <class _Tp, class _Alloc, size_t __bufsize>
+void
+deque<_Tp,_Alloc,__bufsize>::_M_push_back_aux()
+{
+  _M_reserve_map_at_back();
+  *(_M_finish._M_node + 1) = _M_allocate_node();
+  __STL_TRY {
+    construct(_M_finish._M_cur);
+    _M_finish._M_set_node(_M_finish._M_node + 1);
+    _M_finish._M_cur = _M_finish._M_first;
+  }
+  __STL_UNWIND(_M_deallocate_node(*(_M_finish._M_node + 1)));
+}
+
+// Called only if _M_start._M_cur == _M_start._M_first.
+template <class _Tp, class _Alloc, size_t __bufsize>
+void 
+deque<_Tp,_Alloc,__bufsize>::_M_push_front_aux(const value_type& __t)
+{
+  value_type __t_copy = __t;
+  _M_reserve_map_at_front();
+  *(_M_start._M_node - 1) = _M_allocate_node();
+  __STL_TRY {
+    _M_start._M_set_node(_M_start._M_node - 1);
+    _M_start._M_cur = _M_start._M_last - 1;
+    construct(_M_start._M_cur, __t_copy);
+  }
+  __STL_UNWIND((++_M_start, _M_deallocate_node(*(_M_start._M_node - 1))));
+} 
+
+// Called only if _M_start._M_cur == _M_start._M_first.
+template <class _Tp, class _Alloc, size_t __bufsize>
+void 
+deque<_Tp,_Alloc,__bufsize>::_M_push_front_aux()
+{
+  _M_reserve_map_at_front();
+  *(_M_start._M_node - 1) = _M_allocate_node();
+  __STL_TRY {
+    _M_start._M_set_node(_M_start._M_node - 1);
+    _M_start._M_cur = _M_start._M_last - 1;
+    construct(_M_start._M_cur);
+  }
+  __STL_UNWIND((++_M_start, _M_deallocate_node(*(_M_start._M_node - 1))));
+} 
+
+// Called only if _M_finish._M_cur == _M_finish._M_first.
+template <class _Tp, class _Alloc, size_t __bufsize>
+void 
+deque<_Tp,_Alloc,__bufsize>::_M_pop_back_aux()
+{
+  _M_deallocate_node(_M_finish._M_first);
+  _M_finish._M_set_node(_M_finish._M_node - 1);
+  _M_finish._M_cur = _M_finish._M_last - 1;
+  destroy(_M_finish._M_cur);
+}
+
+// Called only if _M_start._M_cur == _M_start._M_last - 1.  Note that 
+// if the deque has at least one element (a precondition for this member 
+// function), and if _M_start._M_cur == _M_start._M_last, then the deque 
+// must have at least two nodes.
+template <class _Tp, class _Alloc, size_t __bufsize>
+void 
+deque<_Tp,_Alloc,__bufsize>::_M_pop_front_aux()
+{
+  destroy(_M_start._M_cur);
+  _M_deallocate_node(_M_start._M_first);
+  _M_start._M_set_node(_M_start._M_node + 1);
+  _M_start._M_cur = _M_start._M_first;
+}      
+
+#ifdef __STL_MEMBER_TEMPLATES  
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+template <class _InputIterator>
+void 
+deque<_Tp,_Alloc,__bufsize>::insert(iterator __pos,
+                                    _InputIterator __first,
+                                    _InputIterator __last,
+                                    input_iterator_tag)
+{
+  copy(__first, __last, inserter(*this, __pos));
+}
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+template <class _ForwardIterator>
+void 
+deque<_Tp,_Alloc,__bufsize>::insert(iterator __pos,
+                                    _ForwardIterator __first,
+                                    _ForwardIterator __last,
+                                    forward_iterator_tag) {
+  size_type __n = 0;
+  distance(__first, __last, __n);
+  if (__pos._M_cur == _M_start._M_cur) {
+    iterator __new_start = _M_reserve_elements_at_front(__n);
+    __STL_TRY {
+      uninitialized_copy(__first, __last, __new_start);
+      _M_start = __new_start;
+    }
+    __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node));
+  }
+  else if (__pos._M_cur == _M_finish._M_cur) {
+    iterator __new_finish = _M_reserve_elements_at_back(__n);
+    __STL_TRY {
+      uninitialized_copy(__first, __last, _M_finish);
+      _M_finish = __new_finish;
+    }
+    __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1, 
+                                  __new_finish._M_node + 1));
+  }
+  else
+    _M_insert_aux(__pos, __first, __last, __n);
+}
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+typename deque<_Tp, _Alloc, __bufsize>::iterator
+deque<_Tp,_Alloc,__bufsize>::_M_insert_aux(iterator __pos,
+                                           const value_type& __x)
+{
+  difference_type __index = __pos - _M_start;
+  value_type __x_copy = __x;
+  if (__index < size() / 2) {
+    push_front(front());
+    iterator __front1 = _M_start;
+    ++__front1;
+    iterator __front2 = __front1;
+    ++__front2;
+    __pos = _M_start + __index;
+    iterator __pos1 = __pos;
+    ++__pos1;
+    copy(__front2, __pos1, __front1);
+  }
+  else {
+    push_back(back());
+    iterator __back1 = _M_finish;
+    --__back1;
+    iterator __back2 = __back1;
+    --__back2;
+    __pos = _M_start + __index;
+    copy_backward(__pos, __back2, __back1);
+  }
+  *__pos = __x_copy;
+  return __pos;
+}
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+typename deque<_Tp,_Alloc,__bufsize>::iterator
+deque<_Tp,_Alloc,__bufsize>::_M_insert_aux(iterator __pos)
+{
+  difference_type __index = __pos - _M_start;
+  if (__index < size() / 2) {
+    push_front(front());
+    iterator __front1 = _M_start;
+    ++__front1;
+    iterator __front2 = __front1;
+    ++__front2;
+    __pos = _M_start + __index;
+    iterator __pos1 = __pos;
+    ++__pos1;
+    copy(__front2, __pos1, __front1);
+  }
+  else {
+    push_back(back());
+    iterator __back1 = _M_finish;
+    --__back1;
+    iterator __back2 = __back1;
+    --__back2;
+    __pos = _M_start + __index;
+    copy_backward(__pos, __back2, __back1);
+  }
+  *__pos = value_type();
+  return __pos;
+}
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+void
+deque<_Tp,_Alloc,__bufsize>::_M_insert_aux(iterator __pos,
+                                           size_type __n,
+                                           const value_type& __x)
+{
+  const difference_type __elems_before = __pos - _M_start;
+  size_type __length = size();
+  value_type __x_copy = __x;
+  if (__elems_before < __length / 2) {
+    iterator __new_start = _M_reserve_elements_at_front(__n);
+    iterator __old_start = _M_start;
+    __pos = _M_start + __elems_before;
+    __STL_TRY {
+      if (__elems_before >= difference_type(__n)) {
+        iterator __start_n = _M_start + difference_type(__n);
+        uninitialized_copy(_M_start, __start_n, __new_start);
+        _M_start = __new_start;
+        copy(__start_n, __pos, __old_start);
+        fill(__pos - difference_type(__n), __pos, __x_copy);
+      }
+      else {
+        __uninitialized_copy_fill(_M_start, __pos, __new_start, 
+	                          _M_start, __x_copy);
+        _M_start = __new_start;
+        fill(__old_start, __pos, __x_copy);
+      }
+    }
+    __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node));
+  }
+  else {
+    iterator __new_finish = _M_reserve_elements_at_back(__n);
+    iterator __old_finish = _M_finish;
+    const difference_type __elems_after = 
+      difference_type(__length) - __elems_before;
+    __pos = _M_finish - __elems_after;
+    __STL_TRY {
+      if (__elems_after > difference_type(__n)) {
+        iterator __finish_n = _M_finish - difference_type(__n);
+        uninitialized_copy(__finish_n, _M_finish, _M_finish);
+        _M_finish = __new_finish;
+        copy_backward(__pos, __finish_n, __old_finish);
+        fill(__pos, __pos + difference_type(__n), __x_copy);
+      }
+      else {
+        __uninitialized_fill_copy(_M_finish, __pos + difference_type(__n),
+                                  __x_copy, __pos, _M_finish);
+        _M_finish = __new_finish;
+        fill(__pos, __old_finish, __x_copy);
+      }
+    }
+    __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1, 
+                                  __new_finish._M_node + 1));
+  }
+}
+
+#ifdef __STL_MEMBER_TEMPLATES  
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+template <class _ForwardIterator>
+void
+deque<_Tp,_Alloc,__bufsize>::_M_insert_aux(iterator __pos,
+                                           _ForwardIterator __first,
+                                           _ForwardIterator __last,
+                                           size_type __n)
+{
+  const difference_type __elemsbefore = __pos - _M_start;
+  size_type __length = size();
+  if (__elemsbefore < __length / 2) {
+    iterator __new_start = _M_reserve_elements_at_front(__n);
+    iterator __old_start = _M_start;
+    __pos = _M_start + __elemsbefore;
+    __STL_TRY {
+      if (__elemsbefore >= difference_type(__n)) {
+        iterator __start_n = _M_start + difference_type(__n); 
+        uninitialized_copy(_M_start, __start_n, __new_start);
+        _M_start = __new_start;
+        copy(__start_n, __pos, __old_start);
+        copy(__first, __last, __pos - difference_type(__n));
+      }
+      else {
+        _ForwardIterator __mid = __first;
+        advance(__mid, difference_type(__n) - __elemsbefore);
+        __uninitialized_copy_copy(_M_start, __pos, __first, __mid,
+                                  __new_start);
+        _M_start = __new_start;
+        copy(__mid, __last, __old_start);
+      }
+    }
+    __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node));
+  }
+  else {
+    iterator __new_finish = _M_reserve_elements_at_back(__n);
+    iterator __old_finish = _M_finish;
+    const difference_type __elemsafter = 
+      difference_type(__length) - __elemsbefore;
+    __pos = _M_finish - __elemsafter;
+    __STL_TRY {
+      if (__elemsafter > difference_type(__n)) {
+        iterator __finish_n = _M_finish - difference_type(__n);
+        uninitialized_copy(__finish_n, _M_finish, _M_finish);
+        _M_finish = __new_finish;
+        copy_backward(__pos, __finish_n, __old_finish);
+        copy(__first, __last, __pos);
+      }
+      else {
+        _ForwardIterator __mid = __first;
+        advance(__mid, __elemsafter);
+        __uninitialized_copy_copy(__mid, __last, __pos, _M_finish, _M_finish);
+        _M_finish = __new_finish;
+        copy(__first, __mid, __pos);
+      }
+    }
+    __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1, 
+                                  __new_finish._M_node + 1));
+  }
+}
+
+#else /* __STL_MEMBER_TEMPLATES */
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+void 
+deque<_Tp,_Alloc,__bufsize>::_M_insert_aux(iterator __pos,
+                                           const value_type* __first,
+                                           const value_type* __last,
+                                           size_type __n)
+{
+  const difference_type __elemsbefore = __pos - _M_start;
+  size_type __length = size();
+  if (__elemsbefore < __length / 2) {
+    iterator __new_start = _M_reserve_elements_at_front(__n);
+    iterator __old_start = _M_start;
+    __pos = _M_start + __elemsbefore;
+    __STL_TRY {
+      if (__elemsbefore >= difference_type(__n)) {
+        iterator __start_n = _M_start + difference_type(__n);
+        uninitialized_copy(_M_start, __start_n, __new_start);
+        _M_start = __new_start;
+        copy(__start_n, __pos, __old_start);
+        copy(__first, __last, __pos - difference_type(__n));
+      }
+      else {
+        const value_type* __mid = 
+	  __first + (difference_type(__n) - __elemsbefore);
+        __uninitialized_copy_copy(_M_start, __pos, __first, __mid,
+                                  __new_start);
+        _M_start = __new_start;
+        copy(__mid, __last, __old_start);
+      }
+    }
+    __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node));
+  }
+  else {
+    iterator __new_finish = _M_reserve_elements_at_back(__n);
+    iterator __old_finish = _M_finish;
+    const difference_type __elemsafter = 
+      difference_type(__length) - __elemsbefore;
+    __pos = _M_finish - __elemsafter;
+    __STL_TRY {
+      if (__elemsafter > difference_type(__n)) {
+        iterator __finish_n = _M_finish - difference_type(__n);
+        uninitialized_copy(__finish_n, _M_finish, _M_finish);
+        _M_finish = __new_finish;
+        copy_backward(__pos, __finish_n, __old_finish);
+        copy(__first, __last, __pos);
+      }
+      else {
+        const value_type* __mid = __first + __elemsafter;
+        __uninitialized_copy_copy(__mid, __last, __pos, _M_finish, _M_finish);
+        _M_finish = __new_finish;
+        copy(__first, __mid, __pos);
+      }
+    }
+    __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1, 
+                                  __new_finish._M_node + 1));
+  }
+}
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+void
+deque<_Tp,_Alloc,__bufsize>::_M_insert_aux(iterator __pos,
+                                           const_iterator __first,
+                                           const_iterator __last,
+                                           size_type __n)
+{
+  const difference_type __elemsbefore = __pos - _M_start;
+  size_type __length = size();
+  if (__elemsbefore < __length / 2) {
+    iterator __new_start = _M_reserve_elements_at_front(__n);
+    iterator __old_start = _M_start;
+    __pos = _M_start + __elemsbefore;
+    __STL_TRY {
+      if (__elemsbefore >= __n) {
+        iterator __start_n = _M_start + __n;
+        uninitialized_copy(_M_start, __start_n, __new_start);
+        _M_start = __new_start;
+        copy(__start_n, __pos, __old_start);
+        copy(__first, __last, __pos - difference_type(__n));
+      }
+      else {
+        const_iterator __mid = __first + (__n - __elemsbefore);
+        __uninitialized_copy_copy(_M_start, __pos, __first, __mid,
+                                  __new_start);
+        _M_start = __new_start;
+        copy(__mid, __last, __old_start);
+      }
+    }
+    __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node));
+  }
+  else {
+    iterator __new_finish = _M_reserve_elements_at_back(__n);
+    iterator __old_finish = _M_finish;
+    const difference_type __elemsafter = __length - __elemsbefore;
+    __pos = _M_finish - __elemsafter;
+    __STL_TRY {
+      if (__elemsafter > __n) {
+        iterator __finish_n = _M_finish - difference_type(__n);
+        uninitialized_copy(__finish_n, _M_finish, _M_finish);
+        _M_finish = __new_finish;
+        copy_backward(__pos, __finish_n, __old_finish);
+        copy(__first, __last, __pos);
+      }
+      else {
+        const_iterator __mid = __first + __elemsafter;
+        __uninitialized_copy_copy(__mid, __last, __pos, _M_finish, _M_finish);
+        _M_finish = __new_finish;
+        copy(__first, __mid, __pos);
+      }
+    }
+    __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1, 
+                 __new_finish._M_node + 1));
+  }
+}
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+void 
+deque<_Tp,_Alloc,__bufsize>::_M_new_elements_at_front(size_type __new_elems)
+{
+  size_type __new_nodes
+      = (__new_elems + _S_buffer_size() - 1) / _S_buffer_size();
+  _M_reserve_map_at_front(__new_nodes);
+  size_type __i;
+  __STL_TRY {
+    for (__i = 1; __i <= __new_nodes; ++__i)
+      *(_M_start._M_node - __i) = _M_allocate_node();
+  }
+#       ifdef __STL_USE_EXCEPTIONS
+  catch(...) {
+    for (size_type __j = 1; __j < __i; ++__j)
+      _M_deallocate_node(*(_M_start._M_node - __j));      
+    throw;
+  }
+#       endif /* __STL_USE_EXCEPTIONS */
+}
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+void 
+deque<_Tp,_Alloc,__bufsize>::_M_new_elements_at_back(size_type __new_elems)
+{
+  size_type __new_nodes
+      = (__new_elems + _S_buffer_size() - 1) / _S_buffer_size();
+  _M_reserve_map_at_back(__new_nodes);
+  size_type __i;
+  __STL_TRY {
+    for (__i = 1; __i <= __new_nodes; ++__i)
+      *(_M_finish._M_node + __i) = _M_allocate_node();
+  }
+#       ifdef __STL_USE_EXCEPTIONS
+  catch(...) {
+    for (size_type __j = 1; __j < __i; ++__j)
+      _M_deallocate_node(*(_M_finish._M_node + __j));      
+    throw;
+  }
+#       endif /* __STL_USE_EXCEPTIONS */
+}
+
+template <class _Tp, class _Alloc, size_t __bufsize>
+void 
+deque<_Tp,_Alloc,__bufsize>::_M_reallocate_map(size_type __nodes_to_add,
+                                              bool __add_at_front)
+{
+  size_type __old_num_nodes = _M_finish._M_node - _M_start._M_node + 1;
+  size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
+
+  _Map_pointer __new_nstart;
+  if (_M_map_size > 2 * __new_num_nodes) {
+    __new_nstart = _M_map + (_M_map_size - __new_num_nodes) / 2 
+                     + (__add_at_front ? __nodes_to_add : 0);
+    if (__new_nstart < _M_start._M_node)
+      copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart);
+    else
+      copy_backward(_M_start._M_node, _M_finish._M_node + 1, 
+                    __new_nstart + __old_num_nodes);
+  }
+  else {
+    size_type __new_map_size = 
+      _M_map_size + max(_M_map_size, __nodes_to_add) + 2;
+
+    _Map_pointer __new_map = _M_allocate_map(__new_map_size);
+    __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
+                         + (__add_at_front ? __nodes_to_add : 0);
+    copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart);
+    _M_deallocate_map(_M_map, _M_map_size);
+
+    _M_map = __new_map;
+    _M_map_size = __new_map_size;
+  }
+
+  _M_start._M_set_node(__new_nstart);
+  _M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
+}
+
+
+// Nonmember functions.
+
+#ifndef __STL_NON_TYPE_TMPL_PARAM_BUG
+
+template <class _Tp, class _Alloc, size_t __bufsiz>
+bool operator==(const deque<_Tp, _Alloc, __bufsiz>& __x,
+                const deque<_Tp, _Alloc, __bufsiz>& __y)
+{
+  return __x.size() == __y.size() &&
+         equal(__x.begin(), __x.end(), __y.begin());
+}
+
+template <class _Tp, class _Alloc, size_t __bufsiz>
+bool operator<(const deque<_Tp, _Alloc, __bufsiz>& __x,
+               const deque<_Tp, _Alloc, __bufsiz>& __y)
+{
+  return lexicographical_compare(__x.begin(), __x.end(), 
+                                 __y.begin(), __y.end());
+}
+
+#endif /* __STL_NON_TYPE_TMPL_PARAM_BUG */
+
+#if defined(__STL_FUNCTION_TMPL_PARTIAL_ORDER) && \
+    !defined(__STL_NON_TYPE_TMPL_PARAM_BUG)
+
+template <class _Tp, class _Alloc, size_t __bufsiz>
+inline void 
+swap(deque<_Tp,_Alloc,__bufsiz>& __x, deque<_Tp,_Alloc,__bufsiz>& __y)
+{
+  __x.swap(__y);
+}
+
+#endif
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1174
+#pragma reset woff 1375
+#endif
+          
+__STL_END_NAMESPACE 
+  
+#endif /* __SGI_STL_INTERNAL_DEQUE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_function.h b/gnu/egcs/libstdc++/stl/stl_function.h
new file mode 100644
index 00000000000..cd07c1c6730
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_function.h
@@ -0,0 +1,700 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_FUNCTION_H
+#define __SGI_STL_INTERNAL_FUNCTION_H
+
+__STL_BEGIN_NAMESPACE
+
+template <class _Arg, class _Result>
+struct unary_function {
+  typedef _Arg argument_type;
+  typedef _Result result_type;
+};
+
+template <class _Arg1, class _Arg2, class _Result>
+struct binary_function {
+  typedef _Arg1 first_argument_type;
+  typedef _Arg2 second_argument_type;
+  typedef _Result result_type;
+};      
+
+template <class _Tp>
+struct plus : public binary_function<_Tp,_Tp,_Tp> {
+  _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x + __y; }
+};
+
+template <class _Tp>
+struct minus : public binary_function<_Tp,_Tp,_Tp> {
+  _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x - __y; }
+};
+
+template <class _Tp>
+struct multiplies : public binary_function<_Tp,_Tp,_Tp> {
+  _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x * __y; }
+};
+
+template <class _Tp>
+struct divides : public binary_function<_Tp,_Tp,_Tp> {
+  _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x / __y; }
+};
+
+// identity_element (not part of the C++ standard).
+
+template <class _Tp> inline _Tp identity_element(plus<_Tp>) {
+  return _Tp(0);
+}
+template <class _Tp> inline _Tp identity_element(multiplies<_Tp>) {
+  return _Tp(1);
+}
+
+template <class _Tp>
+struct modulus : public binary_function<_Tp,_Tp,_Tp> 
+{
+  _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x % __y; }
+};
+
+template <class _Tp>
+struct negate : public unary_function<_Tp,_Tp> 
+{
+  _Tp operator()(const _Tp& __x) const { return -__x; }
+};
+
+template <class _Tp>
+struct equal_to : public binary_function<_Tp,_Tp,bool> 
+{
+  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x == __y; }
+};
+
+template <class _Tp>
+struct not_equal_to : public binary_function<_Tp,_Tp,bool> 
+{
+  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x != __y; }
+};
+
+template <class _Tp>
+struct greater : public binary_function<_Tp,_Tp,bool> 
+{
+  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x > __y; }
+};
+
+template <class _Tp>
+struct less : public binary_function<_Tp,_Tp,bool> 
+{
+  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; }
+};
+
+template <class _Tp>
+struct greater_equal : public binary_function<_Tp,_Tp,bool>
+{
+  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x >= __y; }
+};
+
+template <class _Tp>
+struct less_equal : public binary_function<_Tp,_Tp,bool> 
+{
+  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x <= __y; }
+};
+
+template <class _Tp>
+struct logical_and : public binary_function<_Tp,_Tp,bool>
+{
+  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x && __y; }
+};
+
+template <class _Tp>
+struct logical_or : public binary_function<_Tp,_Tp,bool>
+{
+  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x || __y; }
+};
+
+template <class _Tp>
+struct logical_not : public unary_function<_Tp,bool>
+{
+  bool operator()(const _Tp& __x) const { return !__x; }
+};
+
+template <class _Predicate>
+class unary_negate
+  : public unary_function<typename _Predicate::argument_type, bool> {
+protected:
+  _Predicate _M_pred;
+public:
+  explicit unary_negate(const _Predicate& __x) : _M_pred(__x) {}
+  bool operator()(const typename _Predicate::argument_type& __x) const {
+    return !_M_pred(__x);
+  }
+};
+
+template <class _Predicate>
+inline unary_negate<_Predicate> 
+not1(const _Predicate& __pred)
+{
+  return unary_negate<_Predicate>(__pred);
+}
+
+template <class _Predicate> 
+class binary_negate 
+  : public binary_function<typename _Predicate::first_argument_type,
+                           typename _Predicate::second_argument_type,
+                           bool> {
+protected:
+  _Predicate _M_pred;
+public:
+  explicit binary_negate(const _Predicate& __x) : _M_pred(__x) {}
+  bool operator()(const typename _Predicate::first_argument_type& __x, 
+                  const typename _Predicate::second_argument_type& __y) const
+  {
+    return !_M_pred(__x, __y); 
+  }
+};
+
+template <class _Predicate>
+inline binary_negate<_Predicate> 
+not2(const _Predicate& __pred)
+{
+  return binary_negate<_Predicate>(__pred);
+}
+
+template <class _Operation> 
+class binder1st
+  : public unary_function<typename _Operation::second_argument_type,
+                          typename _Operation::result_type> {
+protected:
+  _Operation op;
+  typename _Operation::first_argument_type value;
+public:
+  binder1st(const _Operation& __x,
+            const typename _Operation::first_argument_type& __y)
+      : op(__x), value(__y) {}
+  typename _Operation::result_type
+  operator()(const typename _Operation::second_argument_type& __x) const {
+    return op(value, __x); 
+  }
+};
+
+template <class _Operation, class _Tp>
+inline binder1st<_Operation> 
+bind1st(const _Operation& __opr, const _Tp& __x) 
+{
+  typedef typename _Operation::first_argument_type _Arg1_type;
+  return binder1st<_Operation>(__opr, _Arg1_type(__x));
+}
+
+template <class _Operation> 
+class binder2nd
+  : public unary_function<typename _Operation::first_argument_type,
+                          typename _Operation::result_type> {
+protected:
+  _Operation op;
+  typename _Operation::second_argument_type value;
+public:
+  binder2nd(const _Operation& __x,
+            const typename _Operation::second_argument_type& __y) 
+      : op(__x), value(__y) {}
+  typename _Operation::result_type
+  operator()(const typename _Operation::first_argument_type& __x) const {
+    return op(__x, value); 
+  }
+};
+
+template <class _Operation, class _Tp>
+inline binder2nd<_Operation> 
+bind2nd(const _Operation& __opr, const _Tp& __x) 
+{
+  typedef typename _Operation::second_argument_type _Arg2_type;
+  return binder2nd<_Operation>(__opr, _Arg2_type(__x));
+}
+
+// unary_compose and binary_compose (extensions, not part of the standard).
+
+template <class _Operation1, class _Operation2>
+class unary_compose
+  : public unary_function<typename _Operation2::argument_type,
+                          typename _Operation1::result_type> 
+{
+protected:
+  _Operation1 __op1;
+  _Operation2 __op2;
+public:
+  unary_compose(const _Operation1& __x, const _Operation2& __y) 
+    : __op1(__x), __op2(__y) {}
+  typename _Operation1::result_type
+  operator()(const typename _Operation2::argument_type& __x) const {
+    return __op1(__op2(__x));
+  }
+};
+
+template <class _Operation1, class _Operation2>
+inline unary_compose<_Operation1,_Operation2> 
+compose1(const _Operation1& __op1, const _Operation2& __op2)
+{
+  return unary_compose<_Operation1,_Operation2>(__op1, __op2);
+}
+
+template <class _Operation1, class _Operation2, class _Operation3>
+class binary_compose
+  : public unary_function<typename _Operation2::argument_type,
+                          typename _Operation1::result_type> {
+protected:
+  _Operation1 _M_op1;
+  _Operation2 _M_op2;
+  _Operation3 _M_op3;
+public:
+  binary_compose(const _Operation1& __x, const _Operation2& __y, 
+                 const _Operation3& __z) 
+    : _M_op1(__x), _M_op2(__y), _M_op3(__z) { }
+  typename _Operation1::result_type
+  operator()(const typename _Operation2::argument_type& __x) const {
+    return _M_op1(_M_op2(__x), _M_op3(__x));
+  }
+};
+
+template <class _Operation1, class _Operation2, class _Operation3>
+inline binary_compose<_Operation1, _Operation2, _Operation3> 
+compose2(const _Operation1& __op1, const _Operation2& __op2, 
+         const _Operation3& __op3)
+{
+  return binary_compose<_Operation1,_Operation2,_Operation3>
+    (__op1, __op2, __op3);
+}
+
+template <class _Arg, class _Result>
+class pointer_to_unary_function : public unary_function<_Arg, _Result> {
+protected:
+  _Result (*_M_ptr)(_Arg);
+public:
+  pointer_to_unary_function() {}
+  explicit pointer_to_unary_function(_Result (*__x)(_Arg)) : _M_ptr(__x) {}
+  _Result operator()(_Arg __x) const { return _M_ptr(__x); }
+};
+
+template <class _Arg, class _Result>
+inline pointer_to_unary_function<_Arg, _Result> ptr_fun(_Result (*__x)(_Arg))
+{
+  return pointer_to_unary_function<_Arg, _Result>(__x);
+}
+
+template <class _Arg1, class _Arg2, class _Result>
+class pointer_to_binary_function : 
+  public binary_function<_Arg1,_Arg2,_Result> {
+protected:
+    _Result (*_M_ptr)(_Arg1, _Arg2);
+public:
+    pointer_to_binary_function() {}
+    explicit pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) 
+      : _M_ptr(__x) {}
+    _Result operator()(_Arg1 __x, _Arg2 __y) const {
+      return _M_ptr(__x, __y);
+    }
+};
+
+template <class _Arg1, class _Arg2, class _Result>
+inline pointer_to_binary_function<_Arg1,_Arg2,_Result> 
+ptr_fun(_Result (*__x)(_Arg1, _Arg2)) {
+  return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__x);
+}
+
+// identity is an extensions: it is not part of the standard.
+template <class _Tp>
+struct _Identity : public unary_function<_Tp,_Tp> {
+  const _Tp& operator()(const _Tp& __x) const { return __x; }
+};
+
+template <class _Tp> struct identity : public _Identity<_Tp> {};
+
+// select1st and select2nd are extensions: they are not part of the standard.
+template <class _Pair>
+struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> {
+  const typename _Pair::first_type& operator()(const _Pair& __x) const {
+    return __x.first;
+  }
+};
+
+template <class _Pair>
+struct _Select2nd : public unary_function<_Pair, typename _Pair::second_type>
+{
+  const typename _Pair::second_type& operator()(const _Pair& __x) const {
+    return __x.second;
+  }
+};
+
+template <class _Pair> struct select1st : public _Select1st<_Pair> {};
+template <class _Pair> struct select2nd : public _Select2nd<_Pair> {};
+
+// project1st and project2nd are extensions: they are not part of the standard
+template <class _Arg1, class _Arg2>
+struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> {
+  _Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; }
+};
+
+template <class _Arg1, class _Arg2>
+struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> {
+  _Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; }
+};
+
+template <class _Arg1, class _Arg2> 
+struct project1st : public _Project1st<_Arg1, _Arg2> {};
+
+template <class _Arg1, class _Arg2>
+struct project2nd : public _Project2nd<_Arg1, _Arg2> {};
+
+// constant_void_fun, constant_unary_fun, and constant_binary_fun are
+// extensions: they are not part of the standard.  (The same, of course,
+// is true of the helper functions constant0, constant1, and constant2.)
+template <class _Result>
+struct constant_void_fun
+{
+  typedef _Result result_type;
+  result_type __val;
+  constant_void_fun(const result_type& __v) : __val(__v) {}
+  const result_type& operator()() const { return __val; }
+};  
+
+#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
+template <class _Result, class _Argument = _Result>
+#else
+template <class _Result, class _Argument>
+#endif
+struct constant_unary_fun : public unary_function<_Argument, _Result> {
+  _Result _M_val;
+  constant_unary_fun(const _Result& __v) : _M_val(__v) {}
+  const _Result& operator()(const _Argument&) const { return _M_val; }
+};
+
+#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
+template <class _Result, class _Arg1 = _Result, class _Arg2 = _Arg1>
+#else
+template <class _Result, class _Arg1, class _Arg2>
+#endif
+struct constant_binary_fun : public binary_function<_Arg1, _Arg2, _Result> {
+  _Result _M_val;
+  constant_binary_fun(const _Result& __v) : _M_val(__v) {}
+  const _Result& operator()(const _Arg1&, const _Arg2&) const {
+    return _M_val;
+  }
+};
+
+template <class _Result>
+inline constant_void_fun<_Result> constant0(const _Result& __val)
+{
+  return constant_void_fun<_Result>(__val);
+}
+
+template <class _Result>
+inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val)
+{
+  return constant_unary_fun<_Result,_Result>(__val);
+}
+
+template <class _Result>
+inline constant_binary_fun<_Result,_Result,_Result> 
+constant2(const _Result& __val)
+{
+  return constant_binary_fun<_Result,_Result,_Result>(__val);
+}
+
+// subtractive_rng is an extension: it is not part of the standard.
+// Note: this code assumes that int is 32 bits.
+class subtractive_rng : public unary_function<unsigned int, unsigned int> {
+private:
+  unsigned int _M_table[55];
+  size_t _M_index1;
+  size_t _M_index2;
+public:
+  unsigned int operator()(unsigned int __limit) {
+    _M_index1 = (_M_index1 + 1) % 55;
+    _M_index2 = (_M_index2 + 1) % 55;
+    _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2];
+    return _M_table[_M_index1] % __limit;
+  }
+
+  void _M_initialize(unsigned int __seed)
+  {
+    unsigned int __k = 1;
+    _M_table[54] = __seed;
+    size_t __i;
+    for (__i = 0; __i < 54; __i++) {
+        size_t __ii = (21 * (__i + 1) % 55) - 1;
+        _M_table[__ii] = __k;
+        __k = __seed - __k;
+        __seed = _M_table[__ii];
+    }
+    for (int __loop = 0; __loop < 4; __loop++) {
+        for (__i = 0; __i < 55; __i++)
+            _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55];
+    }
+    _M_index1 = 0;
+    _M_index2 = 31;
+  }
+
+  subtractive_rng(unsigned int __seed) { _M_initialize(__seed); }
+  subtractive_rng() { _M_initialize(161803398u); }
+};
+
+
+// Adaptor function objects: pointers to member functions.
+
+// There are a total of 16 = 2^4 function objects in this family.
+//  (1) Member functions taking no arguments vs member functions taking
+//       one argument.
+//  (2) Call through pointer vs call through reference.
+//  (3) Member function with void return type vs member function with
+//      non-void return type.
+//  (4) Const vs non-const member function.
+
+// Note that choice (3) is nothing more than a workaround: according
+//  to the draft, compilers should handle void and non-void the same way.
+//  This feature is not yet widely implemented, though.  You can only use
+//  member functions returning void if your compiler supports partial
+//  specialization.
+
+// All of this complexity is in the function objects themselves.  You can
+//  ignore it by using the helper function mem_fun and mem_fun_ref,
+//  which create whichever type of adaptor is appropriate.
+//  (mem_fun1 and mem_fun1_ref are no longer part of the C++ standard,
+//  but they are provided for backward compatibility.)
+
+
+template <class _Ret, class _Tp>
+class mem_fun_t : public unary_function<_Tp*,_Ret> {
+public:
+  explicit mem_fun_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
+  _Ret operator()(_Tp* __p) const { return (__p->*_M_f)(); }
+private:
+  _Ret (_Tp::*_M_f)();
+};
+
+template <class _Ret, class _Tp>
+class const_mem_fun_t : public unary_function<const _Tp*,_Ret> {
+public:
+  explicit const_mem_fun_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
+  _Ret operator()(const _Tp* __p) const { return (__p->*_M_f)(); }
+private:
+  _Ret (_Tp::*_M_f)() const;
+};
+
+
+template <class _Ret, class _Tp>
+class mem_fun_ref_t : public unary_function<_Tp,_Ret> {
+public:
+  explicit mem_fun_ref_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
+  _Ret operator()(_Tp& __r) const { return (__r.*_M_f)(); }
+private:
+  _Ret (_Tp::*_M_f)();
+};
+
+template <class _Ret, class _Tp>
+class const_mem_fun_ref_t : public unary_function<_Tp,_Ret> {
+public:
+  explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
+  _Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); }
+private:
+  _Ret (_Tp::*_M_f)() const;
+};
+
+template <class _Ret, class _Tp, class _Arg>
+class mem_fun1_t : public binary_function<_Tp*,_Arg,_Ret> {
+public:
+  explicit mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
+  _Ret operator()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); }
+private:
+  _Ret (_Tp::*_M_f)(_Arg);
+};
+
+template <class _Ret, class _Tp, class _Arg>
+class const_mem_fun1_t : public binary_function<const _Tp*,_Arg,_Ret> {
+public:
+  explicit const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
+  _Ret operator()(const _Tp* __p, _Arg __x) const
+    { return (__p->*_M_f)(__x); }
+private:
+  _Ret (_Tp::*_M_f)(_Arg) const;
+};
+
+template <class _Ret, class _Tp, class _Arg>
+class mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
+public:
+  explicit mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
+  _Ret operator()(_Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
+private:
+  _Ret (_Tp::*_M_f)(_Arg);
+};
+
+template <class _Ret, class _Tp, class _Arg>
+class const_mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
+public:
+  explicit const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
+  _Ret operator()(const _Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
+private:
+  _Ret (_Tp::*_M_f)(_Arg) const;
+};
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class _Tp>
+class mem_fun_t<void, _Tp> : public unary_function<_Tp*,void> {
+public:
+  explicit mem_fun_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
+  void operator()(_Tp* __p) const { (__p->*_M_f)(); }
+private:
+  void (_Tp::*_M_f)();
+};
+
+template <class _Tp>
+class const_mem_fun_t<void, _Tp> : public unary_function<const _Tp*,void> {
+public:
+  explicit const_mem_fun_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
+  void operator()(const _Tp* __p) const { (__p->*_M_f)(); }
+private:
+  void (_Tp::*_M_f)() const;
+};
+
+template <class _Tp>
+class mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
+public:
+  explicit mem_fun_ref_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
+  void operator()(_Tp& __r) const { (__r.*_M_f)(); }
+private:
+  void (_Tp::*_M_f)();
+};
+
+template <class _Tp>
+class const_mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
+public:
+  explicit const_mem_fun_ref_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
+  void operator()(const _Tp& __r) const { (__r.*_M_f)(); }
+private:
+  void (_Tp::*_M_f)() const;
+};
+
+template <class _Tp, class _Arg>
+class mem_fun1_t<void, _Tp, _Arg> : public binary_function<_Tp*,_Arg,void> {
+public:
+  explicit mem_fun1_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
+  void operator()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
+private:
+  void (_Tp::*_M_f)(_Arg);
+};
+
+template <class _Tp, class _Arg>
+class const_mem_fun1_t<void, _Tp, _Arg> 
+  : public binary_function<const _Tp*,_Arg,void> {
+public:
+  explicit const_mem_fun1_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
+  void operator()(const _Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
+private:
+  void (_Tp::*_M_f)(_Arg) const;
+};
+
+template <class _Tp, class _Arg>
+class mem_fun1_ref_t<void, _Tp, _Arg>
+  : public binary_function<_Tp,_Arg,void> {
+public:
+  explicit mem_fun1_ref_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
+  void operator()(_Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
+private:
+  void (_Tp::*_M_f)(_Arg);
+};
+
+template <class _Tp, class _Arg>
+class const_mem_fun1_ref_t<void, _Tp, _Arg>
+  : public binary_function<_Tp,_Arg,void> {
+public:
+  explicit const_mem_fun1_ref_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
+  void operator()(const _Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
+private:
+  void (_Tp::*_M_f)(_Arg) const;
+};
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+// Mem_fun adaptor helper functions.  There are only two:
+//  mem_fun and mem_fun_ref.  (mem_fun1 and mem_fun1_ref 
+//  are provided for backward compatibility, but they are no longer
+//  part of the C++ standard.)
+
+template <class _Ret, class _Tp>
+inline mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)())
+  { return mem_fun_t<_Ret,_Tp>(__f); }
+
+template <class _Ret, class _Tp>
+inline const_mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)() const)
+  { return const_mem_fun_t<_Ret,_Tp>(__f); }
+
+template <class _Ret, class _Tp>
+inline mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)()) 
+  { return mem_fun_ref_t<_Ret,_Tp>(__f); }
+
+template <class _Ret, class _Tp>
+inline const_mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)() const)
+  { return const_mem_fun_ref_t<_Ret,_Tp>(__f); }
+
+template <class _Ret, class _Tp, class _Arg>
+inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun(_Ret (_Tp::*__f)(_Arg))
+  { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
+
+template <class _Ret, class _Tp, class _Arg>
+inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun(_Ret (_Tp::*__f)(_Arg) const)
+  { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
+
+template <class _Ret, class _Tp, class _Arg>
+inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
+  { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
+
+template <class _Ret, class _Tp, class _Arg>
+inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
+mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
+  { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
+
+template <class _Ret, class _Tp, class _Arg>
+inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg))
+  { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
+
+template <class _Ret, class _Tp, class _Arg>
+inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg) const)
+  { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
+
+template <class _Ret, class _Tp, class _Arg>
+inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg))
+  { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
+
+template <class _Ret, class _Tp, class _Arg>
+inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
+mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const)
+  { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_FUNCTION_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_hash_fun.h b/gnu/egcs/libstdc++/stl/stl_hash_fun.h
new file mode 100644
index 00000000000..44ab9bb5679
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_hash_fun.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_HASH_FUN_H
+#define __SGI_STL_HASH_FUN_H
+
+#include <stddef.h>
+
+__STL_BEGIN_NAMESPACE
+
+template <class _Key> struct hash { };
+
+inline size_t __stl_hash_string(const char* __s)
+{
+  unsigned long __h = 0; 
+  for ( ; *__s; ++__s)
+    __h = 5*__h + *__s;
+  
+  return size_t(__h);
+}
+
+__STL_TEMPLATE_NULL struct hash<char*>
+{
+  size_t operator()(const char* __s) const { return __stl_hash_string(__s); }
+};
+
+__STL_TEMPLATE_NULL struct hash<const char*>
+{
+  size_t operator()(const char* __s) const { return __stl_hash_string(__s); }
+};
+
+__STL_TEMPLATE_NULL struct hash<char> {
+  size_t operator()(char __x) const { return __x; }
+};
+__STL_TEMPLATE_NULL struct hash<unsigned char> {
+  size_t operator()(unsigned char __x) const { return __x; }
+};
+__STL_TEMPLATE_NULL struct hash<signed char> {
+  size_t operator()(unsigned char __x) const { return __x; }
+};
+__STL_TEMPLATE_NULL struct hash<short> {
+  size_t operator()(short __x) const { return __x; }
+};
+__STL_TEMPLATE_NULL struct hash<unsigned short> {
+  size_t operator()(unsigned short __x) const { return __x; }
+};
+__STL_TEMPLATE_NULL struct hash<int> {
+  size_t operator()(int __x) const { return __x; }
+};
+__STL_TEMPLATE_NULL struct hash<unsigned int> {
+  size_t operator()(unsigned int __x) const { return __x; }
+};
+__STL_TEMPLATE_NULL struct hash<long> {
+  size_t operator()(long __x) const { return __x; }
+};
+__STL_TEMPLATE_NULL struct hash<unsigned long> {
+  size_t operator()(unsigned long __x) const { return __x; }
+};
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_HASH_FUN_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_hash_map.h b/gnu/egcs/libstdc++/stl/stl_hash_map.h
new file mode 100644
index 00000000000..bf16f60ecad
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_hash_map.h
@@ -0,0 +1,416 @@
+/*
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_HASH_MAP_H
+#define __SGI_STL_INTERNAL_HASH_MAP_H
+
+
+__STL_BEGIN_NAMESPACE
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1174
+#pragma set woff 1375
+#endif
+
+#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
+template <class _Key, class _Tp, class _HashFcn = hash<_Key>,
+          class _EqualKey = equal_to<_Key>,
+          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
+#else
+template <class _Key, class _Tp, class _HashFcn, class _EqualKey, 
+          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
+#endif
+class hash_map
+{
+private:
+  typedef hashtable<pair<const _Key,_Tp>,_Key,_HashFcn,
+                    _Select1st<pair<const _Key,_Tp> >,_EqualKey,_Alloc> _Ht;
+  _Ht _M_ht;
+
+public:
+  typedef typename _Ht::key_type key_type;
+  typedef _Tp data_type;
+  typedef _Tp mapped_type;
+  typedef typename _Ht::value_type value_type;
+  typedef typename _Ht::hasher hasher;
+  typedef typename _Ht::key_equal key_equal;
+  
+  typedef typename _Ht::size_type size_type;
+  typedef typename _Ht::difference_type difference_type;
+  typedef typename _Ht::pointer pointer;
+  typedef typename _Ht::const_pointer const_pointer;
+  typedef typename _Ht::reference reference;
+  typedef typename _Ht::const_reference const_reference;
+
+  typedef typename _Ht::iterator iterator;
+  typedef typename _Ht::const_iterator const_iterator;
+
+  typedef typename _Ht::allocator_type allocator_type;
+
+  hasher hash_funct() const { return _M_ht.hash_funct(); }
+  key_equal key_eq() const { return _M_ht.key_eq(); }
+  allocator_type get_allocator() const { return _M_ht.get_allocator(); }
+
+public:
+  hash_map() : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
+  explicit hash_map(size_type __n)
+    : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
+  hash_map(size_type __n, const hasher& __hf)
+    : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
+  hash_map(size_type __n, const hasher& __hf, const key_equal& __eql,
+           const allocator_type& __a = allocator_type())
+    : _M_ht(__n, __hf, __eql, __a) {}
+
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  hash_map(_InputIterator __f, _InputIterator __l)
+    : _M_ht(100, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+  template <class _InputIterator>
+  hash_map(_InputIterator __f, _InputIterator __l, size_type __n)
+    : _M_ht(__n, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+  template <class _InputIterator>
+  hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
+           const hasher& __hf)
+    : _M_ht(__n, __hf, key_equal(), allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+  template <class _InputIterator>
+  hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
+           const hasher& __hf, const key_equal& __eql,
+           const allocator_type& __a = allocator_type())
+    : _M_ht(__n, __hf, __eql, __a)
+    { _M_ht.insert_unique(__f, __l); }
+
+#else
+  hash_map(const value_type* __f, const value_type* __l)
+    : _M_ht(100, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+  hash_map(const value_type* __f, const value_type* __l, size_type __n)
+    : _M_ht(__n, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+  hash_map(const value_type* __f, const value_type* __l, size_type __n,
+           const hasher& __hf)
+    : _M_ht(__n, __hf, key_equal(), allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+  hash_map(const value_type* __f, const value_type* __l, size_type __n,
+           const hasher& __hf, const key_equal& __eql,
+           const allocator_type& __a = allocator_type())
+    : _M_ht(__n, __hf, __eql, __a)
+    { _M_ht.insert_unique(__f, __l); }
+
+  hash_map(const_iterator __f, const_iterator __l)
+    : _M_ht(100, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+  hash_map(const_iterator __f, const_iterator __l, size_type __n)
+    : _M_ht(__n, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+  hash_map(const_iterator __f, const_iterator __l, size_type __n,
+           const hasher& __hf)
+    : _M_ht(__n, __hf, key_equal(), allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+  hash_map(const_iterator __f, const_iterator __l, size_type __n,
+           const hasher& __hf, const key_equal& __eql,
+           const allocator_type& __a = allocator_type())
+    : _M_ht(__n, __hf, __eql, __a)
+    { _M_ht.insert_unique(__f, __l); }
+#endif /*__STL_MEMBER_TEMPLATES */
+
+public:
+  size_type size() const { return _M_ht.size(); }
+  size_type max_size() const { return _M_ht.max_size(); }
+  bool empty() const { return _M_ht.empty(); }
+  void swap(hash_map& __hs) { _M_ht.swap(__hs._M_ht); }
+  friend bool
+  operator== __STL_NULL_TMPL_ARGS (const hash_map&, const hash_map&);
+
+  iterator begin() { return _M_ht.begin(); }
+  iterator end() { return _M_ht.end(); }
+  const_iterator begin() const { return _M_ht.begin(); }
+  const_iterator end() const { return _M_ht.end(); }
+
+public:
+  pair<iterator,bool> insert(const value_type& __obj)
+    { return _M_ht.insert_unique(__obj); }
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  void insert(_InputIterator __f, _InputIterator __l)
+    { _M_ht.insert_unique(__f,__l); }
+#else
+  void insert(const value_type* __f, const value_type* __l) {
+    _M_ht.insert_unique(__f,__l);
+  }
+  void insert(const_iterator __f, const_iterator __l)
+    { _M_ht.insert_unique(__f, __l); }
+#endif /*__STL_MEMBER_TEMPLATES */
+  pair<iterator,bool> insert_noresize(const value_type& __obj)
+    { return _M_ht.insert_unique_noresize(__obj); }    
+
+  iterator find(const key_type& __key) { return _M_ht.find(__key); }
+  const_iterator find(const key_type& __key) const 
+    { return _M_ht.find(__key); }
+
+  _Tp& operator[](const key_type& __key) {
+    return _M_ht.find_or_insert(value_type(__key, _Tp())).second;
+  }
+
+  size_type count(const key_type& __key) const { return _M_ht.count(__key); }
+  
+  pair<iterator, iterator> equal_range(const key_type& __key)
+    { return _M_ht.equal_range(__key); }
+  pair<const_iterator, const_iterator>
+  equal_range(const key_type& __key) const
+    { return _M_ht.equal_range(__key); }
+
+  size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
+  void erase(iterator __it) { _M_ht.erase(__it); }
+  void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
+  void clear() { _M_ht.clear(); }
+
+  void resize(size_type __hint) { _M_ht.resize(__hint); }
+  size_type bucket_count() const { return _M_ht.bucket_count(); }
+  size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
+  size_type elems_in_bucket(size_type __n) const
+    { return _M_ht.elems_in_bucket(__n); }
+};
+
+template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
+inline bool 
+operator==(const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1,
+           const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2)
+{
+  return __hm1._M_ht == __hm2._M_ht;
+}
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+
+template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
+inline void 
+swap(hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1,
+     hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2)
+{
+  __hm1.swap(__hm2);
+}
+
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
+template <class _Key, class _Tp, class _HashFcn = hash<_Key>,
+          class _EqualKey = equal_to<_Key>,
+          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
+#else
+template <class _Key, class _Tp, class _HashFcn, class _EqualKey,
+          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
+#endif
+class hash_multimap
+{
+private:
+  typedef hashtable<pair<const _Key, _Tp>, _Key, _HashFcn,
+                    _Select1st<pair<const _Key, _Tp> >, _EqualKey, _Alloc> 
+          _Ht;
+  _Ht _M_ht;
+
+public:
+  typedef typename _Ht::key_type key_type;
+  typedef _Tp data_type;
+  typedef _Tp mapped_type;
+  typedef typename _Ht::value_type value_type;
+  typedef typename _Ht::hasher hasher;
+  typedef typename _Ht::key_equal key_equal;
+
+  typedef typename _Ht::size_type size_type;
+  typedef typename _Ht::difference_type difference_type;
+  typedef typename _Ht::pointer pointer;
+  typedef typename _Ht::const_pointer const_pointer;
+  typedef typename _Ht::reference reference;
+  typedef typename _Ht::const_reference const_reference;
+
+  typedef typename _Ht::iterator iterator;
+  typedef typename _Ht::const_iterator const_iterator;
+
+  typedef typename _Ht::allocator_type allocator_type;
+
+  hasher hash_funct() const { return _M_ht.hash_funct(); }
+  key_equal key_eq() const { return _M_ht.key_eq(); }
+  allocator_type get_allocator() const { return _M_ht.get_allocator(); }
+
+public:
+  hash_multimap() : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
+  explicit hash_multimap(size_type __n)
+    : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
+  hash_multimap(size_type __n, const hasher& __hf)
+    : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
+  hash_multimap(size_type __n, const hasher& __hf, const key_equal& __eql,
+                const allocator_type& __a = allocator_type())
+    : _M_ht(__n, __hf, __eql, __a) {}
+
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  hash_multimap(_InputIterator __f, _InputIterator __l)
+    : _M_ht(100, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+  template <class _InputIterator>
+  hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n)
+    : _M_ht(__n, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+  template <class _InputIterator>
+  hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
+                const hasher& __hf)
+    : _M_ht(__n, __hf, key_equal(), allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+  template <class _InputIterator>
+  hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
+                const hasher& __hf, const key_equal& __eql,
+                const allocator_type& __a = allocator_type())
+    : _M_ht(__n, __hf, __eql, __a)
+    { _M_ht.insert_equal(__f, __l); }
+
+#else
+  hash_multimap(const value_type* __f, const value_type* __l)
+    : _M_ht(100, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+  hash_multimap(const value_type* __f, const value_type* __l, size_type __n)
+    : _M_ht(__n, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+  hash_multimap(const value_type* __f, const value_type* __l, size_type __n,
+                const hasher& __hf)
+    : _M_ht(__n, __hf, key_equal(), allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+  hash_multimap(const value_type* __f, const value_type* __l, size_type __n,
+                const hasher& __hf, const key_equal& __eql,
+                const allocator_type& __a = allocator_type())
+    : _M_ht(__n, __hf, __eql, __a)
+    { _M_ht.insert_equal(__f, __l); }
+
+  hash_multimap(const_iterator __f, const_iterator __l)
+    : _M_ht(100, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+  hash_multimap(const_iterator __f, const_iterator __l, size_type __n)
+    : _M_ht(__n, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+  hash_multimap(const_iterator __f, const_iterator __l, size_type __n,
+                const hasher& __hf)
+    : _M_ht(__n, __hf, key_equal(), allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+  hash_multimap(const_iterator __f, const_iterator __l, size_type __n,
+                const hasher& __hf, const key_equal& __eql,
+                const allocator_type& __a = allocator_type())
+    : _M_ht(__n, __hf, __eql, __a)
+    { _M_ht.insert_equal(__f, __l); }
+#endif /*__STL_MEMBER_TEMPLATES */
+
+public:
+  size_type size() const { return _M_ht.size(); }
+  size_type max_size() const { return _M_ht.max_size(); }
+  bool empty() const { return _M_ht.empty(); }
+  void swap(hash_multimap& __hs) { _M_ht.swap(__hs._M_ht); }
+  friend bool
+  operator== __STL_NULL_TMPL_ARGS (const hash_multimap&,
+                                   const hash_multimap&);
+
+  iterator begin() { return _M_ht.begin(); }
+  iterator end() { return _M_ht.end(); }
+  const_iterator begin() const { return _M_ht.begin(); }
+  const_iterator end() const { return _M_ht.end(); }
+
+public:
+  iterator insert(const value_type& __obj) 
+    { return _M_ht.insert_equal(__obj); }
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  void insert(_InputIterator __f, _InputIterator __l) 
+    { _M_ht.insert_equal(__f,__l); }
+#else
+  void insert(const value_type* __f, const value_type* __l) {
+    _M_ht.insert_equal(__f,__l);
+  }
+  void insert(const_iterator __f, const_iterator __l) 
+    { _M_ht.insert_equal(__f, __l); }
+#endif /*__STL_MEMBER_TEMPLATES */
+  iterator insert_noresize(const value_type& __obj)
+    { return _M_ht.insert_equal_noresize(__obj); }    
+
+  iterator find(const key_type& __key) { return _M_ht.find(__key); }
+  const_iterator find(const key_type& __key) const 
+    { return _M_ht.find(__key); }
+
+  size_type count(const key_type& __key) const { return _M_ht.count(__key); }
+  
+  pair<iterator, iterator> equal_range(const key_type& __key)
+    { return _M_ht.equal_range(__key); }
+  pair<const_iterator, const_iterator>
+  equal_range(const key_type& __key) const
+    { return _M_ht.equal_range(__key); }
+
+  size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
+  void erase(iterator __it) { _M_ht.erase(__it); }
+  void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
+  void clear() { _M_ht.clear(); }
+
+public:
+  void resize(size_type __hint) { _M_ht.resize(__hint); }
+  size_type bucket_count() const { return _M_ht.bucket_count(); }
+  size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
+  size_type elems_in_bucket(size_type __n) const
+    { return _M_ht.elems_in_bucket(__n); }
+};
+
+template <class _Key, class _Tp, class _HF, class _EqKey, class _Alloc>
+inline bool 
+operator==(const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm1,
+           const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm2)
+{
+  return __hm1._M_ht == __hm2._M_ht;
+}
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+
+template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
+inline void 
+swap(hash_multimap<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1,
+     hash_multimap<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2)
+{
+  __hm1.swap(__hm2);
+}
+
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1174
+#pragma reset woff 1375
+#endif
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_HASH_MAP_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_hash_set.h b/gnu/egcs/libstdc++/stl/stl_hash_set.h
new file mode 100644
index 00000000000..b623a642cfc
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_hash_set.h
@@ -0,0 +1,401 @@
+/*
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_HASH_SET_H
+#define __SGI_STL_INTERNAL_HASH_SET_H
+
+__STL_BEGIN_NAMESPACE
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1174
+#pragma set woff 1375
+#endif
+
+#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
+template <class _Value, class _HashFcn = hash<_Value>,
+          class _EqualKey = equal_to<_Value>,
+          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Value) >
+#else
+template <class _Value, class _HashFcn, class _EqualKey, 
+          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Value) >
+#endif
+class hash_set
+{
+private:
+  typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>, 
+                    _EqualKey, _Alloc> _Ht;
+  _Ht _M_ht;
+
+public:
+  typedef typename _Ht::key_type key_type;
+  typedef typename _Ht::value_type value_type;
+  typedef typename _Ht::hasher hasher;
+  typedef typename _Ht::key_equal key_equal;
+
+  typedef typename _Ht::size_type size_type;
+  typedef typename _Ht::difference_type difference_type;
+  typedef typename _Ht::const_pointer pointer;
+  typedef typename _Ht::const_pointer const_pointer;
+  typedef typename _Ht::const_reference reference;
+  typedef typename _Ht::const_reference const_reference;
+
+  typedef typename _Ht::const_iterator iterator;
+  typedef typename _Ht::const_iterator const_iterator;
+
+  typedef typename _Ht::allocator_type allocator_type;
+
+  hasher hash_funct() const { return _M_ht.hash_funct(); }
+  key_equal key_eq() const { return _M_ht.key_eq(); }
+  allocator_type get_allocator() const { return _M_ht.get_allocator(); }
+
+public:
+  hash_set()
+    : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
+  explicit hash_set(size_type __n)
+    : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
+  hash_set(size_type __n, const hasher& __hf)
+    : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
+  hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
+           const allocator_type& __a = allocator_type())
+    : _M_ht(__n, __hf, __eql, __a) {}
+
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  hash_set(_InputIterator __f, _InputIterator __l)
+    : _M_ht(100, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+  template <class _InputIterator>
+  hash_set(_InputIterator __f, _InputIterator __l, size_type __n)
+    : _M_ht(__n, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+  template <class _InputIterator>
+  hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
+           const hasher& __hf)
+    : _M_ht(__n, __hf, key_equal(), allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+  template <class _InputIterator>
+  hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
+           const hasher& __hf, const key_equal& __eql,
+           const allocator_type& __a = allocator_type())
+    : _M_ht(__n, __hf, __eql, __a)
+    { _M_ht.insert_unique(__f, __l); }
+#else
+
+  hash_set(const value_type* __f, const value_type* __l)
+    : _M_ht(100, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+  hash_set(const value_type* __f, const value_type* __l, size_type __n)
+    : _M_ht(__n, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+  hash_set(const value_type* __f, const value_type* __l, size_type __n,
+           const hasher& __hf)
+    : _M_ht(__n, __hf, key_equal(), allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+  hash_set(const value_type* __f, const value_type* __l, size_type __n,
+           const hasher& __hf, const key_equal& __eql,
+           const allocator_type& __a = allocator_type())
+    : _M_ht(__n, __hf, __eql, __a)
+    { _M_ht.insert_unique(__f, __l); }
+
+  hash_set(const_iterator __f, const_iterator __l)
+    : _M_ht(100, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+  hash_set(const_iterator __f, const_iterator __l, size_type __n)
+    : _M_ht(__n, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+  hash_set(const_iterator __f, const_iterator __l, size_type __n,
+           const hasher& __hf)
+    : _M_ht(__n, __hf, key_equal(), allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+  hash_set(const_iterator __f, const_iterator __l, size_type __n,
+           const hasher& __hf, const key_equal& __eql,
+           const allocator_type& __a = allocator_type())
+    : _M_ht(__n, __hf, __eql, __a)
+    { _M_ht.insert_unique(__f, __l); }
+#endif /*__STL_MEMBER_TEMPLATES */
+
+public:
+  size_type size() const { return _M_ht.size(); }
+  size_type max_size() const { return _M_ht.max_size(); }
+  bool empty() const { return _M_ht.empty(); }
+  void swap(hash_set& __hs) { _M_ht.swap(__hs._M_ht); }
+  friend bool operator== __STL_NULL_TMPL_ARGS (const hash_set&,
+                                               const hash_set&);
+
+  iterator begin() const { return _M_ht.begin(); }
+  iterator end() const { return _M_ht.end(); }
+
+public:
+  pair<iterator, bool> insert(const value_type& __obj)
+    {
+      pair<typename _Ht::iterator, bool> __p = _M_ht.insert_unique(__obj);
+      return pair<iterator,bool>(__p.first, __p.second);
+    }
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  void insert(_InputIterator __f, _InputIterator __l) 
+    { _M_ht.insert_unique(__f,__l); }
+#else
+  void insert(const value_type* __f, const value_type* __l) {
+    _M_ht.insert_unique(__f,__l);
+  }
+  void insert(const_iterator __f, const_iterator __l) 
+    {_M_ht.insert_unique(__f, __l); }
+#endif /*__STL_MEMBER_TEMPLATES */
+  pair<iterator, bool> insert_noresize(const value_type& __obj)
+  {
+    pair<typename _Ht::iterator, bool> __p = 
+      _M_ht.insert_unique_noresize(__obj);
+    return pair<iterator, bool>(__p.first, __p.second);
+  }
+
+  iterator find(const key_type& __key) const { return _M_ht.find(__key); }
+
+  size_type count(const key_type& __key) const { return _M_ht.count(__key); }
+  
+  pair<iterator, iterator> equal_range(const key_type& __key) const
+    { return _M_ht.equal_range(__key); }
+
+  size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
+  void erase(iterator __it) { _M_ht.erase(__it); }
+  void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
+  void clear() { _M_ht.clear(); }
+
+public:
+  void resize(size_type __hint) { _M_ht.resize(__hint); }
+  size_type bucket_count() const { return _M_ht.bucket_count(); }
+  size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
+  size_type elems_in_bucket(size_type __n) const
+    { return _M_ht.elems_in_bucket(__n); }
+};
+
+template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+inline bool 
+operator==(const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs1,
+           const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs2)
+{
+  return __hs1._M_ht == __hs2._M_ht;
+}
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+
+template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
+inline void 
+swap(hash_set<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
+     hash_set<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2)
+{
+  __hs1.swap(__hs2);
+}
+
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+
+#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
+template <class _Value, class _HashFcn = hash<_Value>,
+          class _EqualKey = equal_to<_Value>,
+          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Value) >
+#else
+template <class _Value, class _HashFcn, class _EqualKey, 
+          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Value) >
+#endif
+class hash_multiset
+{
+private:
+  typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>, 
+                    _EqualKey, _Alloc> _Ht;
+  _Ht _M_ht;
+
+public:
+  typedef typename _Ht::key_type key_type;
+  typedef typename _Ht::value_type value_type;
+  typedef typename _Ht::hasher hasher;
+  typedef typename _Ht::key_equal key_equal;
+
+  typedef typename _Ht::size_type size_type;
+  typedef typename _Ht::difference_type difference_type;
+  typedef typename _Ht::const_pointer pointer;
+  typedef typename _Ht::const_pointer const_pointer;
+  typedef typename _Ht::const_reference reference;
+  typedef typename _Ht::const_reference const_reference;
+
+  typedef typename _Ht::const_iterator iterator;
+  typedef typename _Ht::const_iterator const_iterator;
+
+  typedef typename _Ht::allocator_type allocator_type;
+
+  hasher hash_funct() const { return _M_ht.hash_funct(); }
+  key_equal key_eq() const { return _M_ht.key_eq(); }
+  allocator_type get_allocator() const { return _M_ht.get_allocator(); }
+
+public:
+  hash_multiset()
+    : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
+  explicit hash_multiset(size_type __n)
+    : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
+  hash_multiset(size_type __n, const hasher& __hf)
+    : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
+  hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql,
+                const allocator_type& __a = allocator_type())
+    : _M_ht(__n, __hf, __eql, __a) {}
+
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  hash_multiset(_InputIterator __f, _InputIterator __l)
+    : _M_ht(100, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+  template <class _InputIterator>
+  hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n)
+    : _M_ht(__n, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+  template <class _InputIterator>
+  hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
+                const hasher& __hf)
+    : _M_ht(__n, __hf, key_equal(), allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+  template <class _InputIterator>
+  hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
+                const hasher& __hf, const key_equal& __eql,
+                const allocator_type& __a = allocator_type())
+    : _M_ht(__n, __hf, __eql, __a)
+    { _M_ht.insert_equal(__f, __l); }
+#else
+
+  hash_multiset(const value_type* __f, const value_type* __l)
+    : _M_ht(100, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+  hash_multiset(const value_type* __f, const value_type* __l, size_type __n)
+    : _M_ht(__n, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+  hash_multiset(const value_type* __f, const value_type* __l, size_type __n,
+                const hasher& __hf)
+    : _M_ht(__n, __hf, key_equal(), allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+  hash_multiset(const value_type* __f, const value_type* __l, size_type __n,
+                const hasher& __hf, const key_equal& __eql,
+                const allocator_type& __a = allocator_type())
+    : _M_ht(__n, __hf, __eql, __a)
+    { _M_ht.insert_equal(__f, __l); }
+
+  hash_multiset(const_iterator __f, const_iterator __l)
+    : _M_ht(100, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+  hash_multiset(const_iterator __f, const_iterator __l, size_type __n)
+    : _M_ht(__n, hasher(), key_equal(), allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+  hash_multiset(const_iterator __f, const_iterator __l, size_type __n,
+                const hasher& __hf)
+    : _M_ht(__n, __hf, key_equal(), allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+  hash_multiset(const_iterator __f, const_iterator __l, size_type __n,
+                const hasher& __hf, const key_equal& __eql,
+                const allocator_type& __a = allocator_type())
+    : _M_ht(__n, __hf, __eql, __a)
+    { _M_ht.insert_equal(__f, __l); }
+#endif /*__STL_MEMBER_TEMPLATES */
+
+public:
+  size_type size() const { return _M_ht.size(); }
+  size_type max_size() const { return _M_ht.max_size(); }
+  bool empty() const { return _M_ht.empty(); }
+  void swap(hash_multiset& hs) { _M_ht.swap(hs._M_ht); }
+  friend bool operator== __STL_NULL_TMPL_ARGS (const hash_multiset&,
+                                               const hash_multiset&);
+
+  iterator begin() const { return _M_ht.begin(); }
+  iterator end() const { return _M_ht.end(); }
+
+public:
+  iterator insert(const value_type& __obj)
+    { return _M_ht.insert_equal(__obj); }
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  void insert(_InputIterator __f, _InputIterator __l) 
+    { _M_ht.insert_equal(__f,__l); }
+#else
+  void insert(const value_type* __f, const value_type* __l) {
+    _M_ht.insert_equal(__f,__l);
+  }
+  void insert(const_iterator __f, const_iterator __l) 
+    { _M_ht.insert_equal(__f, __l); }
+#endif /*__STL_MEMBER_TEMPLATES */
+  iterator insert_noresize(const value_type& __obj)
+    { return _M_ht.insert_equal_noresize(__obj); }    
+
+  iterator find(const key_type& __key) const { return _M_ht.find(__key); }
+
+  size_type count(const key_type& __key) const { return _M_ht.count(__key); }
+  
+  pair<iterator, iterator> equal_range(const key_type& __key) const
+    { return _M_ht.equal_range(__key); }
+
+  size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
+  void erase(iterator __it) { _M_ht.erase(__it); }
+  void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
+  void clear() { _M_ht.clear(); }
+
+public:
+  void resize(size_type __hint) { _M_ht.resize(__hint); }
+  size_type bucket_count() const { return _M_ht.bucket_count(); }
+  size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
+  size_type elems_in_bucket(size_type __n) const
+    { return _M_ht.elems_in_bucket(__n); }
+};
+
+template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
+inline bool 
+operator==(const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
+           const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2)
+{
+  return __hs1._M_ht == __hs2._M_ht;
+}
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+
+template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
+inline void 
+swap(hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
+     hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2) {
+  __hs1.swap(__hs2);
+}
+
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1174
+#pragma reset woff 1375
+#endif
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_HASH_SET_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_hashtable.h b/gnu/egcs/libstdc++/stl/stl_hashtable.h
new file mode 100644
index 00000000000..78b36c1d5a0
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_hashtable.h
@@ -0,0 +1,1039 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_HASHTABLE_H
+#define __SGI_STL_INTERNAL_HASHTABLE_H
+
+// Hashtable class, used to implement the hashed associative containers
+// hash_set, hash_map, hash_multiset, and hash_multimap.
+
+#include <stl_algobase.h>
+#include <stl_alloc.h>
+#include <stl_construct.h>
+#include <stl_tempbuf.h>
+#include <stl_algo.h>
+#include <stl_uninitialized.h>
+#include <stl_function.h>
+#include <stl_vector.h>
+#include <stl_hash_fun.h>
+
+__STL_BEGIN_NAMESPACE
+
+template <class _Val>
+struct _Hashtable_node
+{
+  _Hashtable_node* _M_next;
+  _Val _M_val;
+};  
+
+template <class _Val, class _Key, class _HashFcn,
+          class _ExtractKey, class _EqualKey, class _Alloc = alloc>
+class hashtable;
+
+template <class _Val, class _Key, class _HashFcn,
+          class _ExtractKey, class _EqualKey, class _Alloc>
+struct _Hashtable_iterator;
+
+template <class _Val, class _Key, class _HashFcn,
+          class _ExtractKey, class _EqualKey, class _Alloc>
+struct _Hashtable_const_iterator;
+
+template <class _Val, class _Key, class _HashFcn,
+          class _ExtractKey, class _EqualKey, class _Alloc>
+struct _Hashtable_iterator {
+  typedef hashtable<_Val,_Key,_HashFcn,_ExtractKey,_EqualKey,_Alloc>
+          _Hashtable;
+  typedef _Hashtable_iterator<_Val, _Key, _HashFcn, 
+                              _ExtractKey, _EqualKey, _Alloc>
+          iterator;
+  typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn, 
+                                    _ExtractKey, _EqualKey, _Alloc>
+          const_iterator;
+  typedef _Hashtable_node<_Val> _Node;
+
+  typedef forward_iterator_tag iterator_category;
+  typedef _Val value_type;
+  typedef ptrdiff_t difference_type;
+  typedef size_t size_type;
+  typedef _Val& reference;
+  typedef _Val* pointer;
+
+  _Node* _M_cur;
+  _Hashtable* _M_ht;
+
+  _Hashtable_iterator(_Node* __n, _Hashtable* __tab) 
+    : _M_cur(__n), _M_ht(__tab) {}
+  _Hashtable_iterator() {}
+  reference operator*() const { return _M_cur->_M_val; }
+#ifndef __SGI_STL_NO_ARROW_OPERATOR
+  pointer operator->() const { return &(operator*()); }
+#endif /* __SGI_STL_NO_ARROW_OPERATOR */
+  iterator& operator++();
+  iterator operator++(int);
+  bool operator==(const iterator& __it) const
+    { return _M_cur == __it._M_cur; }
+  bool operator!=(const iterator& __it) const
+    { return _M_cur != __it._M_cur; }
+};
+
+
+template <class _Val, class _Key, class _HashFcn,
+          class _ExtractKey, class _EqualKey, class _Alloc>
+struct _Hashtable_const_iterator {
+  typedef hashtable<_Val,_Key,_HashFcn,_ExtractKey,_EqualKey,_Alloc>
+          _Hashtable;
+  typedef _Hashtable_iterator<_Val,_Key,_HashFcn, 
+                              _ExtractKey,_EqualKey,_Alloc>
+          iterator;
+  typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn, 
+                                    _ExtractKey, _EqualKey, _Alloc>
+          const_iterator;
+  typedef _Hashtable_node<_Val> _Node;
+
+  typedef forward_iterator_tag iterator_category;
+  typedef _Val value_type;
+  typedef ptrdiff_t difference_type;
+  typedef size_t size_type;
+  typedef const _Val& reference;
+  typedef const _Val* pointer;
+
+  const _Node* _M_cur;
+  const _Hashtable* _M_ht;
+
+  _Hashtable_const_iterator(const _Node* __n, const _Hashtable* __tab)
+    : _M_cur(__n), _M_ht(__tab) {}
+  _Hashtable_const_iterator() {}
+  _Hashtable_const_iterator(const iterator& __it) 
+    : _M_cur(__it._M_cur), _M_ht(__it._M_ht) {}
+  reference operator*() const { return _M_cur->_M_val; }
+#ifndef __SGI_STL_NO_ARROW_OPERATOR
+  pointer operator->() const { return &(operator*()); }
+#endif /* __SGI_STL_NO_ARROW_OPERATOR */
+  const_iterator& operator++();
+  const_iterator operator++(int);
+  bool operator==(const const_iterator& __it) const 
+    { return _M_cur == __it._M_cur; }
+  bool operator!=(const const_iterator& __it) const 
+    { return _M_cur != __it._M_cur; }
+};
+
+// Note: assumes long is at least 32 bits.
+static const int __stl_num_primes = 28;
+static const unsigned long __stl_prime_list[__stl_num_primes] =
+{
+  53ul,         97ul,         193ul,       389ul,       769ul,
+  1543ul,       3079ul,       6151ul,      12289ul,     24593ul,
+  49157ul,      98317ul,      196613ul,    393241ul,    786433ul,
+  1572869ul,    3145739ul,    6291469ul,   12582917ul,  25165843ul,
+  50331653ul,   100663319ul,  201326611ul, 402653189ul, 805306457ul, 
+  1610612741ul, 3221225473ul, 4294967291ul
+};
+
+inline unsigned long __stl_next_prime(unsigned long __n)
+{
+  const unsigned long* __first = __stl_prime_list;
+  const unsigned long* __last = __stl_prime_list + __stl_num_primes;
+  const unsigned long* pos = lower_bound(__first, __last, __n);
+  return pos == __last ? *(__last - 1) : *pos;
+}
+
+// Forward declaration of operator==.
+
+template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+class hashtable;
+
+template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+bool operator==(const hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>& __ht1,
+                const hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>& __ht2);
+
+
+// Hashtables handle allocators a bit differently than other containers
+//  do.  If we're using standard-conforming allocators, then a hashtable
+//  unconditionally has a member variable to hold its allocator, even if
+//  it so happens that all instances of the allocator type are identical.
+// This is because, for hashtables, this extra storage is negligible.  
+//  Additionally, a base class wouldn't serve any other purposes; it 
+//  wouldn't, for example, simplify the exception-handling code.
+
+template <class _Val, class _Key, class _HashFcn,
+          class _ExtractKey, class _EqualKey, class _Alloc>
+class hashtable {
+public:
+  typedef _Key key_type;
+  typedef _Val value_type;
+  typedef _HashFcn hasher;
+  typedef _EqualKey key_equal;
+
+  typedef size_t            size_type;
+  typedef ptrdiff_t         difference_type;
+  typedef value_type*       pointer;
+  typedef const value_type* const_pointer;
+  typedef value_type&       reference;
+  typedef const value_type& const_reference;
+
+  hasher hash_funct() const { return _M_hash; }
+  key_equal key_eq() const { return _M_equals; }
+
+private:
+  typedef _Hashtable_node<_Val> _Node;
+
+#ifdef __STL_USE_STD_ALLOCATORS
+public:
+  typedef typename _Alloc_traits<_Val,_Alloc>::allocator_type allocator_type;
+  allocator_type get_allocator() const { return _M_node_allocator; }
+private:
+  typename _Alloc_traits<_Node, _Alloc>::allocator_type _M_node_allocator;
+  _Node* _M_get_node() { return _M_node_allocator.allocate(1); }
+  void _M_put_node(_Node* __p) { _M_node_allocator.deallocate(__p, 1); }
+# define __HASH_ALLOC_INIT(__a) _M_node_allocator(__a), 
+#else /* __STL_USE_STD_ALLOCATORS */
+public:
+  typedef _Alloc allocator_type;
+  allocator_type get_allocator() const { return allocator_type(); }
+private:
+  typedef simple_alloc<_Node, _Alloc> _M_node_allocator_type;
+  _Node* _M_get_node() { return _M_node_allocator_type::allocate(1); }
+  void _M_put_node(_Node* __p) { _M_node_allocator_type::deallocate(__p, 1); }
+# define __HASH_ALLOC_INIT(__a)
+#endif /* __STL_USE_STD_ALLOCATORS */
+
+private:
+  hasher                _M_hash;
+  key_equal             _M_equals;
+  _ExtractKey           _M_get_key;
+  vector<_Node*,_Alloc> _M_buckets;
+  size_type             _M_num_elements;
+
+public:
+  typedef _Hashtable_iterator<_Val,_Key,_HashFcn,_ExtractKey,_EqualKey,_Alloc>
+          iterator;
+  typedef _Hashtable_const_iterator<_Val,_Key,_HashFcn,_ExtractKey,_EqualKey,
+                                    _Alloc>
+          const_iterator;
+
+  friend struct
+  _Hashtable_iterator<_Val,_Key,_HashFcn,_ExtractKey,_EqualKey,_Alloc>;
+  friend struct
+  _Hashtable_const_iterator<_Val,_Key,_HashFcn,_ExtractKey,_EqualKey,_Alloc>;
+
+public:
+  hashtable(size_type __n,
+            const _HashFcn&    __hf,
+            const _EqualKey&   __eql,
+            const _ExtractKey& __ext,
+            const allocator_type& __a = allocator_type())
+    : __HASH_ALLOC_INIT(__a)
+      _M_hash(__hf),
+      _M_equals(__eql),
+      _M_get_key(__ext),
+      _M_buckets(__a),
+      _M_num_elements(0)
+  {
+    _M_initialize_buckets(__n);
+  }
+
+  hashtable(size_type __n,
+            const _HashFcn&    __hf,
+            const _EqualKey&   __eql,
+            const allocator_type& __a = allocator_type())
+    : __HASH_ALLOC_INIT(__a)
+      _M_hash(__hf),
+      _M_equals(__eql),
+      _M_get_key(_ExtractKey()),
+      _M_buckets(__a),
+      _M_num_elements(0)
+  {
+    _M_initialize_buckets(__n);
+  }
+
+  hashtable(const hashtable& __ht)
+    : __HASH_ALLOC_INIT(__ht.get_allocator())
+      _M_hash(__ht._M_hash),
+      _M_equals(__ht._M_equals),
+      _M_get_key(__ht._M_get_key),
+      _M_buckets(__ht.get_allocator()),
+      _M_num_elements(0)
+  {
+    _M_copy_from(__ht);
+  }
+
+#undef __HASH_ALLOC_INIT
+
+  hashtable& operator= (const hashtable& __ht)
+  {
+    if (&__ht != this) {
+      clear();
+      _M_hash = __ht._M_hash;
+      _M_equals = __ht._M_equals;
+      _M_get_key = __ht._M_get_key;
+      _M_copy_from(__ht);
+    }
+    return *this;
+  }
+
+  ~hashtable() { clear(); }
+
+  size_type size() const { return _M_num_elements; }
+  size_type max_size() const { return size_type(-1); }
+  bool empty() const { return size() == 0; }
+
+  void swap(hashtable& __ht)
+  {
+    __STD::swap(_M_hash, __ht._M_hash);
+    __STD::swap(_M_equals, __ht._M_equals);
+    __STD::swap(_M_get_key, __ht._M_get_key);
+    _M_buckets.swap(__ht._M_buckets);
+    __STD::swap(_M_num_elements, __ht._M_num_elements);
+  }
+
+  iterator begin()
+  { 
+    for (size_type __n = 0; __n < _M_buckets.size(); ++__n)
+      if (_M_buckets[__n])
+        return iterator(_M_buckets[__n], this);
+    return end();
+  }
+
+  iterator end() { return iterator(0, this); }
+
+  const_iterator begin() const
+  {
+    for (size_type __n = 0; __n < _M_buckets.size(); ++__n)
+      if (_M_buckets[__n])
+        return const_iterator(_M_buckets[__n], this);
+    return end();
+  }
+
+  const_iterator end() const { return const_iterator(0, this); }
+
+  friend bool
+  operator== __STL_NULL_TMPL_ARGS (const hashtable&, const hashtable&);
+
+public:
+
+  size_type bucket_count() const { return _M_buckets.size(); }
+
+  size_type max_bucket_count() const
+    { return __stl_prime_list[__stl_num_primes - 1]; } 
+
+  size_type elems_in_bucket(size_type __bucket) const
+  {
+    size_type __result = 0;
+    for (_Node* __cur = _M_buckets[__bucket]; __cur; __cur = __cur->_M_next)
+      __result += 1;
+    return __result;
+  }
+
+  pair<iterator, bool> insert_unique(const value_type& __obj)
+  {
+    resize(_M_num_elements + 1);
+    return insert_unique_noresize(__obj);
+  }
+
+  iterator insert_equal(const value_type& __obj)
+  {
+    resize(_M_num_elements + 1);
+    return insert_equal_noresize(__obj);
+  }
+
+  pair<iterator, bool> insert_unique_noresize(const value_type& __obj);
+  iterator insert_equal_noresize(const value_type& __obj);
+ 
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  void insert_unique(_InputIterator __f, _InputIterator __l)
+  {
+    insert_unique(__f, __l, __ITERATOR_CATEGORY(__f));
+  }
+
+  template <class _InputIterator>
+  void insert_equal(_InputIterator __f, _InputIterator __l)
+  {
+    insert_equal(__f, __l, __ITERATOR_CATEGORY(__f));
+  }
+
+  template <class _InputIterator>
+  void insert_unique(_InputIterator __f, _InputIterator __l,
+                     input_iterator_tag)
+  {
+    for ( ; __f != __l; ++__f)
+      insert_unique(*__f);
+  }
+
+  template <class _InputIterator>
+  void insert_equal(_InputIterator __f, _InputIterator __l,
+                    input_iterator_tag)
+  {
+    for ( ; __f != __l; ++__f)
+      insert_equal(*__f);
+  }
+
+  template <class _ForwardIterator>
+  void insert_unique(_ForwardIterator __f, _ForwardIterator __l,
+                     forward_iterator_tag)
+  {
+    size_type __n = 0;
+    distance(__f, __l, __n);
+    resize(_M_num_elements + __n);
+    for ( ; __n > 0; --__n, ++__f)
+      insert_unique_noresize(*__f);
+  }
+
+  template <class _ForwardIterator>
+  void insert_equal(_ForwardIterator __f, _ForwardIterator __l,
+                    forward_iterator_tag)
+  {
+    size_type __n = 0;
+    distance(__f, __l, __n);
+    resize(_M_num_elements + __n);
+    for ( ; __n > 0; --__n, ++__f)
+      insert_equal_noresize(*__f);
+  }
+
+#else /* __STL_MEMBER_TEMPLATES */
+  void insert_unique(const value_type* __f, const value_type* __l)
+  {
+    size_type __n = __l - __f;
+    resize(_M_num_elements + __n);
+    for ( ; __n > 0; --__n, ++__f)
+      insert_unique_noresize(*__f);
+  }
+
+  void insert_equal(const value_type* __f, const value_type* __l)
+  {
+    size_type __n = __l - __f;
+    resize(_M_num_elements + __n);
+    for ( ; __n > 0; --__n, ++__f)
+      insert_equal_noresize(*__f);
+  }
+
+  void insert_unique(const_iterator __f, const_iterator __l)
+  {
+    size_type __n = 0;
+    distance(__f, __l, __n);
+    resize(_M_num_elements + __n);
+    for ( ; __n > 0; --__n, ++__f)
+      insert_unique_noresize(*__f);
+  }
+
+  void insert_equal(const_iterator __f, const_iterator __l)
+  {
+    size_type __n = 0;
+    distance(__f, __l, __n);
+    resize(_M_num_elements + __n);
+    for ( ; __n > 0; --__n, ++__f)
+      insert_equal_noresize(*__f);
+  }
+#endif /*__STL_MEMBER_TEMPLATES */
+
+  reference find_or_insert(const value_type& __obj);
+
+  iterator find(const key_type& __key) 
+  {
+    size_type __n = _M_bkt_num_key(__key);
+    _Node* __first;
+    for ( __first = _M_buckets[__n];
+          __first && !_M_equals(_M_get_key(__first->_M_val), __key);
+          __first = __first->_M_next)
+      {}
+    return iterator(__first, this);
+  } 
+
+  const_iterator find(const key_type& __key) const
+  {
+    size_type __n = _M_bkt_num_key(__key);
+    const _Node* __first;
+    for ( __first = _M_buckets[__n];
+          __first && !_M_equals(_M_get_key(__first->_M_val), __key);
+          __first = __first->_M_next)
+      {}
+    return const_iterator(__first, this);
+  } 
+
+  size_type count(const key_type& __key) const
+  {
+    const size_type __n = _M_bkt_num_key(__key);
+    size_type __result = 0;
+
+    for (const _Node* __cur = _M_buckets[__n]; __cur; __cur = __cur->_M_next)
+      if (_M_equals(_M_get_key(__cur->_M_val), __key))
+        ++__result;
+    return __result;
+  }
+
+  pair<iterator, iterator> 
+  equal_range(const key_type& __key);
+
+  pair<const_iterator, const_iterator> 
+  equal_range(const key_type& __key) const;
+
+  size_type erase(const key_type& __key);
+  void erase(const iterator& __it);
+  void erase(iterator __first, iterator __last);
+
+  void erase(const const_iterator& __it);
+  void erase(const_iterator __first, const_iterator __last);
+
+  void resize(size_type __num_elements_hint);
+  void clear();
+
+private:
+  size_type _M_next_size(size_type __n) const
+    { return __stl_next_prime(__n); }
+
+  void _M_initialize_buckets(size_type __n)
+  {
+    const size_type __n_buckets = _M_next_size(__n);
+    _M_buckets.reserve(__n_buckets);
+    _M_buckets.insert(_M_buckets.end(), __n_buckets, (_Node*) 0);
+    _M_num_elements = 0;
+  }
+
+  size_type _M_bkt_num_key(const key_type& __key) const
+  {
+    return _M_bkt_num_key(__key, _M_buckets.size());
+  }
+
+  size_type _M_bkt_num(const value_type& __obj) const
+  {
+    return _M_bkt_num_key(_M_get_key(__obj));
+  }
+
+  size_type _M_bkt_num_key(const key_type& __key, size_t __n) const
+  {
+    return _M_hash(__key) % __n;
+  }
+
+  size_type _M_bkt_num(const value_type& __obj, size_t __n) const
+  {
+    return _M_bkt_num_key(_M_get_key(__obj), __n);
+  }
+
+  _Node* _M_new_node(const value_type& __obj)
+  {
+    _Node* __n = _M_get_node();
+    __n->_M_next = 0;
+    __STL_TRY {
+      construct(&__n->_M_val, __obj);
+      return __n;
+    }
+    __STL_UNWIND(_M_put_node(__n));
+  }
+  
+  void _M_delete_node(_Node* __n)
+  {
+    destroy(&__n->_M_val);
+    _M_put_node(__n);
+  }
+
+  void _M_erase_bucket(const size_type __n, _Node* __first, _Node* __last);
+  void _M_erase_bucket(const size_type __n, _Node* __last);
+
+  void _M_copy_from(const hashtable& __ht);
+
+};
+
+template <class _Val, class _Key, class _HF, class _ExK, class _EqK, 
+          class _All>
+_Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>&
+_Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>::operator++()
+{
+  const _Node* __old = _M_cur;
+  _M_cur = _M_cur->_M_next;
+  if (!_M_cur) {
+    size_type __bucket = _M_ht->_M_bkt_num(__old->_M_val);
+    while (!_M_cur && ++__bucket < _M_ht->_M_buckets.size())
+      _M_cur = _M_ht->_M_buckets[__bucket];
+  }
+  return *this;
+}
+
+template <class _Val, class _Key, class _HF, class _ExK, class _EqK, 
+          class _All>
+inline _Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>
+_Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>::operator++(int)
+{
+  iterator __tmp = *this;
+  ++*this;
+  return __tmp;
+}
+
+template <class _Val, class _Key, class _HF, class _ExK, class _EqK, 
+          class _All>
+_Hashtable_const_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>&
+_Hashtable_const_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>::operator++()
+{
+  const _Node* __old = _M_cur;
+  _M_cur = _M_cur->_M_next;
+  if (!_M_cur) {
+    size_type __bucket = _M_ht->_M_bkt_num(__old->_M_val);
+    while (!_M_cur && ++__bucket < _M_ht->_M_buckets.size())
+      _M_cur = _M_ht->_M_buckets[__bucket];
+  }
+  return *this;
+}
+
+template <class _Val, class _Key, class _HF, class _ExK, class _EqK, 
+          class _All>
+inline _Hashtable_const_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>
+_Hashtable_const_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>::operator++(int)
+{
+  const_iterator __tmp = *this;
+  ++*this;
+  return __tmp;
+}
+
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class _Val, class _Key, class _HF, class _ExK, class _EqK, 
+          class _All>
+inline forward_iterator_tag
+iterator_category(const _Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>&)
+{
+  return forward_iterator_tag();
+}
+
+template <class _Val, class _Key, class _HF, class _ExK, class _EqK, 
+          class _All>
+inline _Val* 
+value_type(const _Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>&)
+{
+  return (_Val*) 0;
+}
+
+template <class _Val, class _Key, class _HF, class _ExK, class _EqK, 
+          class _All>
+inline hashtable<_Val,_Key,_HF,_ExK,_EqK,_All>::difference_type*
+distance_type(const _Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>&)
+{
+  return (hashtable<_Val,_Key,_HF,_ExK,_EqK,_All>::difference_type*) 0;
+}
+
+template <class _Val, class _Key, class _HF, class _ExK, class _EqK, 
+          class _All>
+inline forward_iterator_tag
+iterator_category(const _Hashtable_const_iterator<_Val,_Key,_HF,
+                                                  _ExK,_EqK,_All>&)
+{
+  return forward_iterator_tag();
+}
+
+template <class _Val, class _Key, class _HF, class _ExK, class _EqK, 
+          class _All>
+inline _Val* 
+value_type(const _Hashtable_const_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>&)
+{
+  return (_Val*) 0;
+}
+
+template <class _Val, class _Key, class _HF, class _ExK, class _EqK, 
+          class _All>
+inline hashtable<_Val,_Key,_HF,_ExK,_EqK,_All>::difference_type*
+distance_type(const _Hashtable_const_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>&)
+{
+  return (hashtable<_Val,_Key,_HF,_ExK,_EqK,_All>::difference_type*) 0;
+}
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+inline bool operator==(const hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>& __ht1,
+                       const hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>& __ht2)
+{
+  typedef typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::_Node _Node;
+  if (__ht1._M_buckets.size() != __ht2._M_buckets.size())
+    return false;
+  for (int __n = 0; __n < __ht1._M_buckets.size(); ++__n) {
+    _Node* __cur1 = __ht1._M_buckets[__n];
+    _Node* __cur2 = __ht2._M_buckets[__n];
+    for ( ; __cur1 && __cur2 && __cur1->_M_val == __cur2->_M_val;
+          __cur1 = __cur1->_M_next, __cur2 = __cur2->_M_next)
+      {}
+    if (__cur1 || __cur2)
+      return false;
+  }
+  return true;
+}  
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+
+template <class _Val, class _Key, class _HF, class _Extract, class _EqKey, 
+          class _All>
+inline void swap(hashtable<_Val, _Key, _HF, _Extract, _EqKey, _All>& __ht1,
+                 hashtable<_Val, _Key, _HF, _Extract, _EqKey, _All>& __ht2) {
+  __ht1.swap(__ht2);
+}
+
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+
+template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+pair<typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator, bool> 
+hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
+  ::insert_unique_noresize(const value_type& __obj)
+{
+  const size_type __n = _M_bkt_num(__obj);
+  _Node* __first = _M_buckets[__n];
+
+  for (_Node* __cur = __first; __cur; __cur = __cur->_M_next) 
+    if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj)))
+      return pair<iterator, bool>(iterator(__cur, this), false);
+
+  _Node* __tmp = _M_new_node(__obj);
+  __tmp->_M_next = __first;
+  _M_buckets[__n] = __tmp;
+  ++_M_num_elements;
+  return pair<iterator, bool>(iterator(__tmp, this), true);
+}
+
+template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator 
+hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
+  ::insert_equal_noresize(const value_type& __obj)
+{
+  const size_type __n = _M_bkt_num(__obj);
+  _Node* __first = _M_buckets[__n];
+
+  for (_Node* __cur = __first; __cur; __cur = __cur->_M_next) 
+    if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj))) {
+      _Node* __tmp = _M_new_node(__obj);
+      __tmp->_M_next = __cur->_M_next;
+      __cur->_M_next = __tmp;
+      ++_M_num_elements;
+      return iterator(__tmp, this);
+    }
+
+  _Node* __tmp = _M_new_node(__obj);
+  __tmp->_M_next = __first;
+  _M_buckets[__n] = __tmp;
+  ++_M_num_elements;
+  return iterator(__tmp, this);
+}
+
+template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::reference 
+hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::find_or_insert(const value_type& __obj)
+{
+  resize(_M_num_elements + 1);
+
+  size_type __n = _M_bkt_num(__obj);
+  _Node* __first = _M_buckets[__n];
+
+  for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
+    if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj)))
+      return __cur->_M_val;
+
+  _Node* __tmp = _M_new_node(__obj);
+  __tmp->_M_next = __first;
+  _M_buckets[__n] = __tmp;
+  ++_M_num_elements;
+  return __tmp->_M_val;
+}
+
+template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+pair<typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator,
+     typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator> 
+hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::equal_range(const key_type& __key)
+{
+  typedef pair<iterator, iterator> _Pii;
+  const size_type __n = _M_bkt_num_key(__key);
+
+  for (_Node* __first = _M_buckets[__n]; __first; __first = __first->_M_next)
+    if (_M_equals(_M_get_key(__first->_M_val), __key)) {
+      for (_Node* __cur = __first->_M_next; __cur; __cur = __cur->_M_next)
+        if (!_M_equals(_M_get_key(__cur->_M_val), __key))
+          return _Pii(iterator(__first, this), iterator(__cur, this));
+      for (size_type __m = __n + 1; __m < _M_buckets.size(); ++__m)
+        if (_M_buckets[__m])
+          return _Pii(iterator(__first, this),
+                     iterator(_M_buckets[__m], this));
+      return _Pii(iterator(__first, this), end());
+    }
+  return _Pii(end(), end());
+}
+
+template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+pair<typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::const_iterator, 
+     typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::const_iterator> 
+hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
+  ::equal_range(const key_type& __key) const
+{
+  typedef pair<const_iterator, const_iterator> _Pii;
+  const size_type __n = _M_bkt_num_key(__key);
+
+  for (const _Node* __first = _M_buckets[__n] ;
+       __first; 
+       __first = __first->_M_next) {
+    if (_M_equals(_M_get_key(__first->_M_val), __key)) {
+      for (const _Node* __cur = __first->_M_next;
+           __cur;
+           __cur = __cur->_M_next)
+        if (!_M_equals(_M_get_key(__cur->_M_val), __key))
+          return _Pii(const_iterator(__first, this),
+                      const_iterator(__cur, this));
+      for (size_type __m = __n + 1; __m < _M_buckets.size(); ++__m)
+        if (_M_buckets[__m])
+          return _Pii(const_iterator(__first, this),
+                      const_iterator(_M_buckets[__m], this));
+      return _Pii(const_iterator(__first, this), end());
+    }
+  }
+  return _Pii(end(), end());
+}
+
+template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::size_type 
+hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::erase(const key_type& __key)
+{
+  const size_type __n = _M_bkt_num_key(__key);
+  _Node* __first = _M_buckets[__n];
+  size_type __erased = 0;
+
+  if (__first) {
+    _Node* __cur = __first;
+    _Node* __next = __cur->_M_next;
+    while (__next) {
+      if (_M_equals(_M_get_key(__next->_M_val), __key)) {
+        __cur->_M_next = __next->_M_next;
+        _M_delete_node(__next);
+        __next = __cur->_M_next;
+        ++__erased;
+        --_M_num_elements;
+      }
+      else {
+        __cur = __next;
+        __next = __cur->_M_next;
+      }
+    }
+    if (_M_equals(_M_get_key(__first->_M_val), __key)) {
+      _M_buckets[__n] = __first->_M_next;
+      _M_delete_node(__first);
+      ++__erased;
+      --_M_num_elements;
+    }
+  }
+  return __erased;
+}
+
+template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::erase(const iterator& __it)
+{
+  if (_Node* const __p = __it._M_cur) {
+    const size_type __n = _M_bkt_num(__p->_M_val);
+    _Node* __cur = _M_buckets[__n];
+
+    if (__cur == __p) {
+      _M_buckets[__n] = __cur->_M_next;
+      _M_delete_node(__cur);
+      --_M_num_elements;
+    }
+    else {
+      _Node* __next = __cur->_M_next;
+      while (__next) {
+        if (__next == __p) {
+          __cur->_M_next = __next->_M_next;
+          _M_delete_node(__next);
+          --_M_num_elements;
+          break;
+        }
+        else {
+          __cur = __next;
+          __next = __cur->_M_next;
+        }
+      }
+    }
+  }
+}
+
+template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
+  ::erase(iterator __first, iterator __last)
+{
+  size_type __f_bucket = __first._M_cur ? 
+    _M_bkt_num(__first._M_cur->_M_val) : _M_buckets.size();
+  size_type __l_bucket = __last._M_cur ? 
+    _M_bkt_num(__last._M_cur->_M_val) : _M_buckets.size();
+
+  if (__first._M_cur == __last._M_cur)
+    return;
+  else if (__f_bucket == __l_bucket)
+    _M_erase_bucket(__f_bucket, __first._M_cur, __last._M_cur);
+  else {
+    _M_erase_bucket(__f_bucket, __first._M_cur, 0);
+    for (size_type __n = __f_bucket + 1; __n < __l_bucket; ++__n)
+      _M_erase_bucket(__n, 0);
+    if (__l_bucket != _M_buckets.size())
+      _M_erase_bucket(__l_bucket, __last._M_cur);
+  }
+}
+
+template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+inline void
+hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::erase(const_iterator __first,
+                                             const_iterator __last)
+{
+  erase(iterator(const_cast<_Node*>(__first._M_cur),
+                 const_cast<hashtable*>(__first._M_ht)),
+        iterator(const_cast<_Node*>(__last._M_cur),
+                 const_cast<hashtable*>(__last._M_ht)));
+}
+
+template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+inline void
+hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::erase(const const_iterator& __it)
+{
+  erase(iterator(const_cast<_Node*>(__it._M_cur),
+                 const_cast<hashtable*>(__it._M_ht)));
+}
+
+template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
+  ::resize(size_type __num_elements_hint)
+{
+  const size_type __old_n = _M_buckets.size();
+  if (__num_elements_hint > __old_n) {
+    const size_type __n = _M_next_size(__num_elements_hint);
+    if (__n > __old_n) {
+      vector<_Node*, _All> __tmp(__n, (_Node*)(0),
+                                 _M_buckets.get_allocator());
+      __STL_TRY {
+        for (size_type __bucket = 0; __bucket < __old_n; ++__bucket) {
+          _Node* __first = _M_buckets[__bucket];
+          while (__first) {
+            size_type __new_bucket = _M_bkt_num(__first->_M_val, __n);
+            _M_buckets[__bucket] = __first->_M_next;
+            __first->_M_next = __tmp[__new_bucket];
+            __tmp[__new_bucket] = __first;
+            __first = _M_buckets[__bucket];          
+          }
+        }
+        _M_buckets.swap(__tmp);
+      }
+#         ifdef __STL_USE_EXCEPTIONS
+      catch(...) {
+        for (size_type __bucket = 0; __bucket < __tmp.size(); ++__bucket) {
+          while (__tmp[__bucket]) {
+            _Node* __next = __tmp[__bucket]->_M_next;
+            _M_delete_node(__tmp[__bucket]);
+            __tmp[__bucket] = __next;
+          }
+        }
+        throw;
+      }
+#         endif /* __STL_USE_EXCEPTIONS */
+    }
+  }
+}
+
+template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
+  ::_M_erase_bucket(const size_type __n, _Node* __first, _Node* __last)
+{
+  _Node* __cur = _M_buckets[__n];
+  if (__cur == __first)
+    _M_erase_bucket(__n, __last);
+  else {
+    _Node* __next;
+    for (__next = __cur->_M_next; 
+         __next != __first; 
+         __cur = __next, __next = __cur->_M_next)
+      ;
+    while (__next) {
+      __cur->_M_next = __next->_M_next;
+      _M_delete_node(__next);
+      __next = __cur->_M_next;
+      --_M_num_elements;
+    }
+  }
+}
+
+template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
+  ::_M_erase_bucket(const size_type __n, _Node* __last)
+{
+  _Node* __cur = _M_buckets[__n];
+  while (__cur != __last) {
+    _Node* __next = __cur->_M_next;
+    _M_delete_node(__cur);
+    __cur = __next;
+    _M_buckets[__n] = __cur;
+    --_M_num_elements;
+  }
+}
+
+template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::clear()
+{
+  for (size_type __i = 0; __i < _M_buckets.size(); ++__i) {
+    _Node* __cur = _M_buckets[__i];
+    while (__cur != 0) {
+      _Node* __next = __cur->_M_next;
+      _M_delete_node(__cur);
+      __cur = __next;
+    }
+    _M_buckets[__i] = 0;
+  }
+  _M_num_elements = 0;
+}
+
+    
+template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
+  ::_M_copy_from(const hashtable& __ht)
+{
+  _M_buckets.clear();
+  _M_buckets.reserve(__ht._M_buckets.size());
+  _M_buckets.insert(_M_buckets.end(), __ht._M_buckets.size(), (_Node*) 0);
+  __STL_TRY {
+    for (size_type __i = 0; __i < __ht._M_buckets.size(); ++__i) {
+      if (const _Node* __cur = __ht._M_buckets[__i]) {
+        _Node* __copy = _M_new_node(__cur->_M_val);
+        _M_buckets[__i] = __copy;
+
+        for (_Node* __next = __cur->_M_next; 
+             __next; 
+             __cur = __next, __next = __cur->_M_next) {
+          __copy->_M_next = _M_new_node(__next->_M_val);
+          __copy = __copy->_M_next;
+        }
+      }
+    }
+    _M_num_elements = __ht._M_num_elements;
+  }
+  __STL_UNWIND(clear());
+}
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_HASHTABLE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_heap.h b/gnu/egcs/libstdc++/stl/stl_heap.h
new file mode 100644
index 00000000000..62f142ec970
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_heap.h
@@ -0,0 +1,281 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_HEAP_H
+#define __SGI_STL_INTERNAL_HEAP_H
+
+__STL_BEGIN_NAMESPACE
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1209
+#endif
+
+// Heap-manipulation functions: push_heap, pop_heap, make_heap, sort_heap.
+
+template <class _RandomAccessIterator, class _Distance, class _Tp>
+void 
+__push_heap(_RandomAccessIterator __first,
+            _Distance __holeIndex, _Distance __topIndex, _Tp __value)
+{
+  _Distance __parent = (__holeIndex - 1) / 2;
+  while (__holeIndex > __topIndex && *(__first + __parent) < __value) {
+    *(__first + __holeIndex) = *(__first + __parent);
+    __holeIndex = __parent;
+    __parent = (__holeIndex - 1) / 2;
+  }    
+  *(__first + __holeIndex) = __value;
+}
+
+template <class _RandomAccessIterator, class _Distance, class _Tp>
+inline void 
+__push_heap_aux(_RandomAccessIterator __first,
+                _RandomAccessIterator __last, _Distance*, _Tp*)
+{
+  __push_heap(__first, _Distance((__last - __first) - 1), _Distance(0), 
+              _Tp(*(__last - 1)));
+}
+
+template <class _RandomAccessIterator>
+inline void 
+push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+{
+  __push_heap_aux(__first, __last,
+                  __DISTANCE_TYPE(__first), __VALUE_TYPE(__first));
+}
+
+template <class _RandomAccessIterator, class _Distance, class _Tp, 
+          class _Compare>
+void
+__push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+            _Distance __topIndex, _Tp __value, _Compare __comp)
+{
+  _Distance __parent = (__holeIndex - 1) / 2;
+  while (__holeIndex > __topIndex && __comp(*(__first + __parent), __value)) {
+    *(__first + __holeIndex) = *(__first + __parent);
+    __holeIndex = __parent;
+    __parent = (__holeIndex - 1) / 2;
+  }
+  *(__first + __holeIndex) = __value;
+}
+
+template <class _RandomAccessIterator, class _Compare,
+          class _Distance, class _Tp>
+inline void 
+__push_heap_aux(_RandomAccessIterator __first,
+                _RandomAccessIterator __last, _Compare __comp,
+                _Distance*, _Tp*) 
+{
+  __push_heap(__first, _Distance((__last - __first) - 1), _Distance(0), 
+              _Tp(*(__last - 1)), __comp);
+}
+
+template <class _RandomAccessIterator, class _Compare>
+inline void 
+push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+          _Compare __comp)
+{
+  __push_heap_aux(__first, __last, __comp,
+                  __DISTANCE_TYPE(__first), __VALUE_TYPE(__first));
+}
+
+template <class _RandomAccessIterator, class _Distance, class _Tp>
+void 
+__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+              _Distance __len, _Tp __value)
+{
+  _Distance __topIndex = __holeIndex;
+  _Distance __secondChild = 2 * __holeIndex + 2;
+  while (__secondChild < __len) {
+    if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
+      __secondChild--;
+    *(__first + __holeIndex) = *(__first + __secondChild);
+    __holeIndex = __secondChild;
+    __secondChild = 2 * (__secondChild + 1);
+  }
+  if (__secondChild == __len) {
+    *(__first + __holeIndex) = *(__first + (__secondChild - 1));
+    __holeIndex = __secondChild - 1;
+  }
+  __push_heap(__first, __holeIndex, __topIndex, __value);
+}
+
+template <class _RandomAccessIterator, class _Tp, class _Distance>
+inline void 
+__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+           _RandomAccessIterator __result, _Tp __value, _Distance*)
+{
+  *__result = *__first;
+  __adjust_heap(__first, _Distance(0), _Distance(__last - __first), __value);
+}
+
+template <class _RandomAccessIterator, class _Tp>
+inline void 
+__pop_heap_aux(_RandomAccessIterator __first, _RandomAccessIterator __last,
+               _Tp*)
+{
+  __pop_heap(__first, __last - 1, __last - 1, 
+             _Tp(*(__last - 1)), __DISTANCE_TYPE(__first));
+}
+
+template <class _RandomAccessIterator>
+inline void pop_heap(_RandomAccessIterator __first, 
+                     _RandomAccessIterator __last)
+{
+  __pop_heap_aux(__first, __last, __VALUE_TYPE(__first));
+}
+
+template <class _RandomAccessIterator, class _Distance,
+          class _Tp, class _Compare>
+void
+__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+              _Distance __len, _Tp __value, _Compare __comp)
+{
+  _Distance __topIndex = __holeIndex;
+  _Distance __secondChild = 2 * __holeIndex + 2;
+  while (__secondChild < __len) {
+    if (__comp(*(__first + __secondChild), *(__first + (__secondChild - 1))))
+      __secondChild--;
+    *(__first + __holeIndex) = *(__first + __secondChild);
+    __holeIndex = __secondChild;
+    __secondChild = 2 * (__secondChild + 1);
+  }
+  if (__secondChild == __len) {
+    *(__first + __holeIndex) = *(__first + (__secondChild - 1));
+    __holeIndex = __secondChild - 1;
+  }
+  __push_heap(__first, __holeIndex, __topIndex, __value, __comp);
+}
+
+template <class _RandomAccessIterator, class _Tp, class _Compare, 
+          class _Distance>
+inline void 
+__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+           _RandomAccessIterator __result, _Tp __value, _Compare __comp,
+           _Distance*)
+{
+  *__result = *__first;
+  __adjust_heap(__first, _Distance(0), _Distance(__last - __first), 
+                __value, __comp);
+}
+
+template <class _RandomAccessIterator, class _Tp, class _Compare>
+inline void 
+__pop_heap_aux(_RandomAccessIterator __first,
+               _RandomAccessIterator __last, _Tp*, _Compare __comp)
+{
+  __pop_heap(__first, __last - 1, __last - 1, _Tp(*(__last - 1)), __comp,
+             __DISTANCE_TYPE(__first));
+}
+
+template <class _RandomAccessIterator, class _Compare>
+inline void 
+pop_heap(_RandomAccessIterator __first,
+         _RandomAccessIterator __last, _Compare __comp)
+{
+    __pop_heap_aux(__first, __last, __VALUE_TYPE(__first), __comp);
+}
+
+template <class _RandomAccessIterator, class _Tp, class _Distance>
+void 
+__make_heap(_RandomAccessIterator __first,
+            _RandomAccessIterator __last, _Tp*, _Distance*)
+{
+  if (__last - __first < 2) return;
+  _Distance __len = __last - __first;
+  _Distance __parent = (__len - 2)/2;
+    
+  while (true) {
+    __adjust_heap(__first, __parent, __len, _Tp(*(__first + __parent)));
+    if (__parent == 0) return;
+    __parent--;
+  }
+}
+
+template <class _RandomAccessIterator>
+inline void 
+make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+{
+  __make_heap(__first, __last,
+              __VALUE_TYPE(__first), __DISTANCE_TYPE(__first));
+}
+
+template <class _RandomAccessIterator, class _Compare,
+          class _Tp, class _Distance>
+void
+__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+            _Compare __comp, _Tp*, _Distance*)
+{
+  if (__last - __first < 2) return;
+  _Distance __len = __last - __first;
+  _Distance __parent = (__len - 2)/2;
+    
+  while (true) {
+    __adjust_heap(__first, __parent, __len, _Tp(*(__first + __parent)),
+                  __comp);
+    if (__parent == 0) return;
+    __parent--;
+  }
+}
+
+template <class _RandomAccessIterator, class _Compare>
+inline void 
+make_heap(_RandomAccessIterator __first, 
+          _RandomAccessIterator __last, _Compare __comp)
+{
+  __make_heap(__first, __last, __comp,
+              __VALUE_TYPE(__first), __DISTANCE_TYPE(__first));
+}
+
+template <class _RandomAccessIterator>
+void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+{
+  while (__last - __first > 1)
+    pop_heap(__first, __last--);
+}
+
+template <class _RandomAccessIterator, class _Compare>
+void 
+sort_heap(_RandomAccessIterator __first,
+          _RandomAccessIterator __last, _Compare __comp)
+{
+  while (__last - __first > 1)
+    pop_heap(__first, __last--, __comp);
+}
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1209
+#endif
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_HEAP_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_iterator.h b/gnu/egcs/libstdc++/stl/stl_iterator.h
new file mode 100644
index 00000000000..e2bd7149692
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_iterator.h
@@ -0,0 +1,915 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_ITERATOR_H
+#define __SGI_STL_INTERNAL_ITERATOR_H
+
+__STL_BEGIN_NAMESPACE
+
+struct input_iterator_tag {};
+struct output_iterator_tag {};
+struct forward_iterator_tag : public input_iterator_tag {};
+struct bidirectional_iterator_tag : public forward_iterator_tag {};
+struct random_access_iterator_tag : public bidirectional_iterator_tag {};
+
+// The base classes input_iterator, output_iterator, forward_iterator,
+// bidirectional_iterator, and random_access_iterator are not part of
+// the C++ standard.  (they have been replaced by struct iterator.)
+// They are included for backward compatibility with the HP STL.
+
+template <class _Tp, class _Distance> struct input_iterator {
+  typedef input_iterator_tag iterator_category;
+  typedef _Tp                value_type;
+  typedef _Distance          difference_type;
+  typedef _Tp*               pointer;
+  typedef _Tp&               reference;
+};
+
+struct output_iterator {
+  typedef output_iterator_tag iterator_category;
+  typedef void                value_type;
+  typedef void                difference_type;
+  typedef void                pointer;
+  typedef void                reference;
+};
+
+template <class _Tp, class _Distance> struct forward_iterator {
+  typedef forward_iterator_tag iterator_category;
+  typedef _Tp                  value_type;
+  typedef _Distance            difference_type;
+  typedef _Tp*                 pointer;
+  typedef _Tp&                 reference;
+};
+
+
+template <class _Tp, class _Distance> struct bidirectional_iterator {
+  typedef bidirectional_iterator_tag iterator_category;
+  typedef _Tp                        value_type;
+  typedef _Distance                  difference_type;
+  typedef _Tp*                       pointer;
+  typedef _Tp&                       reference;
+};
+
+template <class _Tp, class _Distance> struct random_access_iterator {
+  typedef random_access_iterator_tag iterator_category;
+  typedef _Tp                        value_type;
+  typedef _Distance                  difference_type;
+  typedef _Tp*                       pointer;
+  typedef _Tp&                       reference;
+};
+
+#ifdef __STL_USE_NAMESPACES
+template <class _Category, class _Tp, class _Distance = ptrdiff_t,
+          class _Pointer = _Tp*, class _Reference = _Tp&>
+struct iterator {
+  typedef _Category  iterator_category;
+  typedef _Tp        value_type;
+  typedef _Distance  difference_type;
+  typedef _Pointer   pointer;
+  typedef _Reference reference;
+};
+#endif /* __STL_USE_NAMESPACES */
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class _Iterator>
+struct iterator_traits {
+  typedef typename _Iterator::iterator_category iterator_category;
+  typedef typename _Iterator::value_type        value_type;
+  typedef typename _Iterator::difference_type   difference_type;
+  typedef typename _Iterator::pointer           pointer;
+  typedef typename _Iterator::reference         reference;
+};
+
+template <class _Tp>
+struct iterator_traits<_Tp*> {
+  typedef random_access_iterator_tag iterator_category;
+  typedef _Tp                         value_type;
+  typedef ptrdiff_t                   difference_type;
+  typedef _Tp*                        pointer;
+  typedef _Tp&                        reference;
+};
+
+template <class _Tp>
+struct iterator_traits<const _Tp*> {
+  typedef random_access_iterator_tag iterator_category;
+  typedef _Tp                         value_type;
+  typedef ptrdiff_t                   difference_type;
+  typedef const _Tp*                  pointer;
+  typedef const _Tp&                  reference;
+};
+
+// The overloaded functions iterator_category, distance_type, and
+// value_type are not part of the C++ standard.  (They have been
+// replaced by struct iterator_traits.)  They are included for
+// backward compatibility with the HP STL.
+
+// We introduce internal names for these functions.
+
+template <class _Iter>
+inline typename iterator_traits<_Iter>::iterator_category
+__iterator_category(const _Iter&)
+{
+  typedef typename iterator_traits<_Iter>::iterator_category _Category;
+  return _Category();
+}
+
+template <class _Iter>
+inline typename iterator_traits<_Iter>::difference_type*
+__distance_type(const _Iter&)
+{
+  return static_cast<typename iterator_traits<_Iter>::difference_type*>(0);
+}
+
+template <class _Iter>
+inline typename iterator_traits<_Iter>::value_type*
+__value_type(const _Iter&)
+{
+  return static_cast<typename iterator_traits<_Iter>::value_type*>(0);
+}
+
+template <class _Iter>
+inline typename iterator_traits<_Iter>::iterator_category
+iterator_category(const _Iter& __i) { return __iterator_category(__i); }
+
+
+template <class _Iter>
+inline typename iterator_traits<_Iter>::difference_type*
+distance_type(const _Iter& __i) { return __distance_type(__i); }
+
+template <class _Iter>
+inline typename iterator_traits<_Iter>::value_type*
+value_type(const _Iter& __i) { return __value_type(__i); }
+
+#define __ITERATOR_CATEGORY(__i) __iterator_category(__i)
+#define __DISTANCE_TYPE(__i)     __distance_type(__i)
+#define __VALUE_TYPE(__i)        __value_type(__i)
+
+#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+template <class _Tp, class _Distance> 
+inline input_iterator_tag 
+iterator_category(const input_iterator<_Tp, _Distance>&)
+  { return input_iterator_tag(); }
+
+inline output_iterator_tag iterator_category(const output_iterator&)
+  { return output_iterator_tag(); }
+
+template <class _Tp, class _Distance> 
+inline forward_iterator_tag
+iterator_category(const forward_iterator<_Tp, _Distance>&)
+  { return forward_iterator_tag(); }
+
+template <class _Tp, class _Distance> 
+inline bidirectional_iterator_tag
+iterator_category(const bidirectional_iterator<_Tp, _Distance>&)
+  { return bidirectional_iterator_tag(); }
+
+template <class _Tp, class _Distance> 
+inline random_access_iterator_tag
+iterator_category(const random_access_iterator<_Tp, _Distance>&)
+  { return random_access_iterator_tag(); }
+
+template <class _Tp>
+inline random_access_iterator_tag iterator_category(const _Tp*)
+  { return random_access_iterator_tag(); }
+
+template <class _Tp, class _Distance> 
+inline _Tp* value_type(const input_iterator<_Tp, _Distance>&)
+  { return (_Tp*)(0); }
+
+template <class _Tp, class _Distance> 
+inline _Tp* value_type(const forward_iterator<_Tp, _Distance>&)
+  { return (_Tp*)(0); }
+
+template <class _Tp, class _Distance> 
+inline _Tp* value_type(const bidirectional_iterator<_Tp, _Distance>&)
+  { return (_Tp*)(0); }
+
+template <class _Tp, class _Distance> 
+inline _Tp* value_type(const random_access_iterator<_Tp, _Distance>&)
+  { return (_Tp*)(0); }
+
+template <class _Tp>
+inline _Tp* value_type(const _Tp*) { return (_Tp*)(0); }
+
+template <class _Tp, class _Distance> 
+inline _Distance* distance_type(const input_iterator<_Tp, _Distance>&)
+{
+  return (_Distance*)(0);
+}
+
+template <class _Tp, class _Distance> 
+inline _Distance* distance_type(const forward_iterator<_Tp, _Distance>&)
+{
+  return (_Distance*)(0);
+}
+
+template <class _Tp, class _Distance> 
+inline _Distance* 
+distance_type(const bidirectional_iterator<_Tp, _Distance>&)
+{
+  return (_Distance*)(0);
+}
+
+template <class _Tp, class _Distance> 
+inline _Distance* 
+distance_type(const random_access_iterator<_Tp, _Distance>&)
+{
+  return (_Distance*)(0);
+}
+
+template <class _Tp>
+inline ptrdiff_t* distance_type(const _Tp*) { return (ptrdiff_t*)(0); }
+
+// Without partial specialization we can't use iterator_traits, so
+// we must keep the old iterator query functions around.  
+
+#define __ITERATOR_CATEGORY(__i) iterator_category(__i)
+#define __DISTANCE_TYPE(__i)     distance_type(__i)
+#define __VALUE_TYPE(__i)        value_type(__i)
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+template <class _InputIterator, class _Distance>
+inline void __distance(_InputIterator __first, _InputIterator __last,
+                       _Distance& __n, input_iterator_tag)
+{
+  while (__first != __last) { ++__first; ++__n; }
+}
+
+template <class _RandomAccessIterator, class _Distance>
+inline void __distance(_RandomAccessIterator __first, 
+                       _RandomAccessIterator __last, 
+                       _Distance& __n, random_access_iterator_tag)
+{
+  __n += __last - __first;
+}
+
+template <class _InputIterator, class _Distance>
+inline void distance(_InputIterator __first, 
+                     _InputIterator __last, _Distance& __n)
+{
+  __distance(__first, __last, __n, iterator_category(__first));
+}
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class _InputIterator>
+inline typename iterator_traits<_InputIterator>::difference_type
+__distance(_InputIterator __first, _InputIterator __last, input_iterator_tag)
+{
+  typename iterator_traits<_InputIterator>::difference_type __n = 0;
+  while (__first != __last) {
+    ++__first; ++__n;
+  }
+  return __n;
+}
+
+template <class _RandomAccessIterator>
+inline typename iterator_traits<_RandomAccessIterator>::difference_type
+__distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
+           random_access_iterator_tag) {
+  return __last - __first;
+}
+
+template <class _InputIterator>
+inline typename iterator_traits<_InputIterator>::difference_type
+distance(_InputIterator __first, _InputIterator __last) {
+  typedef typename iterator_traits<_InputIterator>::iterator_category 
+    _Category;
+  return __distance(__first, __last, _Category());
+}
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+template <class _InputIter, class _Distance>
+inline void __advance(_InputIter& __i, _Distance __n, input_iterator_tag) {
+  while (__n--) ++__i;
+}
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1183
+#endif
+
+template <class _BidirectionalIterator, class _Distance>
+inline void __advance(_BidirectionalIterator& __i, _Distance __n, 
+                      bidirectional_iterator_tag) {
+  if (__n >= 0)
+    while (__n--) ++__i;
+  else
+    while (__n++) --__i;
+}
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1183
+#endif
+
+template <class _RandomAccessIterator, class _Distance>
+inline void __advance(_RandomAccessIterator& __i, _Distance __n, 
+                      random_access_iterator_tag) {
+  __i += __n;
+}
+
+template <class _InputIterator, class _Distance>
+inline void advance(_InputIterator& __i, _Distance __n) {
+  __advance(__i, __n, iterator_category(__i));
+}
+
+template <class _Container>
+class back_insert_iterator {
+protected:
+  _Container* container;
+public:
+  typedef _Container          container_type;
+  typedef output_iterator_tag iterator_category;
+  typedef void                value_type;
+  typedef void                difference_type;
+  typedef void                pointer;
+  typedef void                reference;
+
+  explicit back_insert_iterator(_Container& __x) : container(&__x) {}
+  back_insert_iterator<_Container>&
+  operator=(const typename _Container::value_type& __value) { 
+    container->push_back(__value);
+    return *this;
+  }
+  back_insert_iterator<_Container>& operator*() { return *this; }
+  back_insert_iterator<_Container>& operator++() { return *this; }
+  back_insert_iterator<_Container>& operator++(int) { return *this; }
+};
+
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class _Container>
+inline output_iterator_tag
+iterator_category(const back_insert_iterator<_Container>&)
+{
+  return output_iterator_tag();
+}
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+template <class _Container>
+inline back_insert_iterator<_Container> back_inserter(_Container& __x) {
+  return back_insert_iterator<_Container>(__x);
+}
+
+template <class _Container>
+class front_insert_iterator {
+protected:
+  _Container* container;
+public:
+  typedef _Container          container_type;
+  typedef output_iterator_tag iterator_category;
+  typedef void                value_type;
+  typedef void                difference_type;
+  typedef void                pointer;
+  typedef void                reference;
+
+  explicit front_insert_iterator(_Container& __x) : container(&__x) {}
+  front_insert_iterator<_Container>&
+  operator=(const typename _Container::value_type& __value) { 
+    container->push_front(__value);
+    return *this;
+  }
+  front_insert_iterator<_Container>& operator*() { return *this; }
+  front_insert_iterator<_Container>& operator++() { return *this; }
+  front_insert_iterator<_Container>& operator++(int) { return *this; }
+};
+
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class _Container>
+inline output_iterator_tag
+iterator_category(const front_insert_iterator<_Container>&)
+{
+  return output_iterator_tag();
+}
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+template <class _Container>
+inline front_insert_iterator<_Container> front_inserter(_Container& __x) {
+  return front_insert_iterator<_Container>(__x);
+}
+
+template <class _Container>
+class insert_iterator {
+protected:
+  _Container* container;
+  typename _Container::iterator iter;
+public:
+  typedef _Container          container_type;
+  typedef output_iterator_tag iterator_category;
+  typedef void                value_type;
+  typedef void                difference_type;
+  typedef void                pointer;
+  typedef void                reference;
+
+  insert_iterator(_Container& __x, typename _Container::iterator __i) 
+    : container(&__x), iter(__i) {}
+  insert_iterator<_Container>&
+  operator=(const typename _Container::value_type& __value) { 
+    iter = container->insert(iter, __value);
+    ++iter;
+    return *this;
+  }
+  insert_iterator<_Container>& operator*() { return *this; }
+  insert_iterator<_Container>& operator++() { return *this; }
+  insert_iterator<_Container>& operator++(int) { return *this; }
+};
+
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class _Container>
+inline output_iterator_tag
+iterator_category(const insert_iterator<_Container>&)
+{
+  return output_iterator_tag();
+}
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+template <class _Container, class _Iterator>
+inline 
+insert_iterator<_Container> inserter(_Container& __x, _Iterator __i)
+{
+  typedef typename _Container::iterator __iter;
+  return insert_iterator<_Container>(__x, __iter(__i));
+}
+
+#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
+template <class _BidirectionalIterator, class _Tp, class _Reference = _Tp&, 
+          class _Distance = ptrdiff_t> 
+#else
+template <class _BidirectionalIterator, class _Tp, class _Reference, 
+          class _Distance> 
+#endif
+class reverse_bidirectional_iterator {
+  typedef reverse_bidirectional_iterator<_BidirectionalIterator, _Tp, 
+                                         _Reference, _Distance>  _Self;
+protected:
+  _BidirectionalIterator current;
+public:
+  typedef bidirectional_iterator_tag iterator_category;
+  typedef _Tp                        value_type;
+  typedef _Distance                  difference_type;
+  typedef _Tp*                       pointer;
+  typedef _Reference                 reference;
+
+  reverse_bidirectional_iterator() {}
+  explicit reverse_bidirectional_iterator(_BidirectionalIterator __x)
+    : current(__x) {}
+  _BidirectionalIterator base() const { return current; }
+  _Reference operator*() const {
+    _BidirectionalIterator __tmp = current;
+    return *--__tmp;
+  }
+#ifndef __SGI_STL_NO_ARROW_OPERATOR
+  pointer operator->() const { return &(operator*()); }
+#endif /* __SGI_STL_NO_ARROW_OPERATOR */
+  _Self& operator++() {
+    --current;
+    return *this;
+  }
+  _Self operator++(int) {
+    _Self __tmp = *this;
+    --current;
+    return __tmp;
+  }
+  _Self& operator--() {
+    ++current;
+    return *this;
+  }
+  _Self operator--(int) {
+    _Self __tmp = *this;
+    ++current;
+    return __tmp;
+  }
+};
+
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class _BidirectionalIterator, class _Tp, class _Reference, 
+          class _Distance>
+inline bidirectional_iterator_tag
+iterator_category(const reverse_bidirectional_iterator<_BidirectionalIterator,
+                                                       _Tp, _Reference, 
+                                                       _Distance>&) 
+{
+  return bidirectional_iterator_tag();
+}
+
+template <class _BidirectionalIterator, class _Tp, class _Reference, 
+          class _Distance>
+inline _Tp*
+value_type(const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
+                                               _Reference, _Distance>&)
+{
+  return (_Tp*) 0;
+}
+
+template <class _BidirectionalIterator, class _Tp, class _Reference, 
+          class _Distance>
+inline _Distance*
+distance_type(const reverse_bidirectional_iterator<_BidirectionalIterator, 
+                                                   _Tp,
+                                                   _Reference, _Distance>&)
+{
+  return (_Distance*) 0;
+}
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+template <class _BiIter, class _Tp, class _Ref,
+          class _Distance>
+inline bool operator==(
+    const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __x, 
+    const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __y)
+{
+  return __x.base() == __y.base();
+}
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+// This is the new version of reverse_iterator, as defined in the
+//  draft C++ standard.  It relies on the iterator_traits template,
+//  which in turn relies on partial specialization.  The class
+//  reverse_bidirectional_iterator is no longer part of the draft
+//  standard, but it is retained for backward compatibility.
+
+template <class _Iterator>
+class reverse_iterator 
+{
+protected:
+  _Iterator current;
+public:
+  typedef typename iterator_traits<_Iterator>::iterator_category
+          iterator_category;
+  typedef typename iterator_traits<_Iterator>::value_type
+          value_type;
+  typedef typename iterator_traits<_Iterator>::difference_type
+          difference_type;
+  typedef typename iterator_traits<_Iterator>::pointer
+          pointer;
+  typedef typename iterator_traits<_Iterator>::reference
+          reference;
+
+  typedef _Iterator iterator_type;
+  typedef reverse_iterator<_Iterator> _Self;
+
+public:
+  reverse_iterator() {}
+  explicit reverse_iterator(iterator_type __x) : current(__x) {}
+
+  reverse_iterator(const _Self& __x) : current(__x.current) {}
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _Iter>
+  reverse_iterator(const reverse_iterator<_Iter>& __x)
+    : current(__x.base()) {}
+#endif /* __STL_MEMBER_TEMPLATES */
+    
+  iterator_type base() const { return current; }
+  reference operator*() const {
+    _Iterator __tmp = current;
+    return *--__tmp;
+  }
+#ifndef __SGI_STL_NO_ARROW_OPERATOR
+  pointer operator->() const { return &(operator*()); }
+#endif /* __SGI_STL_NO_ARROW_OPERATOR */
+
+  _Self& operator++() {
+    --current;
+    return *this;
+  }
+  _Self operator++(int) {
+    _Self __tmp = *this;
+    --current;
+    return __tmp;
+  }
+  _Self& operator--() {
+    ++current;
+    return *this;
+  }
+  _Self operator--(int) {
+    _Self __tmp = *this;
+    ++current;
+    return __tmp;
+  }
+
+  _Self operator+(difference_type __n) const {
+    return _Self(current - __n);
+  }
+  _Self& operator+=(difference_type __n) {
+    current -= __n;
+    return *this;
+  }
+  _Self operator-(difference_type __n) const {
+    return _Self(current + __n);
+  }
+  _Self& operator-=(difference_type __n) {
+    current += __n;
+    return *this;
+  }
+  reference operator[](difference_type __n) const { return *(*this + __n); }  
+}; 
+ 
+template <class _Iterator>
+inline bool operator==(const reverse_iterator<_Iterator>& __x, 
+                       const reverse_iterator<_Iterator>& __y) {
+  return __x.base() == __y.base();
+}
+
+template <class _Iterator>
+inline bool operator<(const reverse_iterator<_Iterator>& __x, 
+                      const reverse_iterator<_Iterator>& __y) {
+  return __y.base() < __x.base();
+}
+
+template <class _Iterator>
+inline typename reverse_iterator<_Iterator>::difference_type
+operator-(const reverse_iterator<_Iterator>& __x, 
+          const reverse_iterator<_Iterator>& __y) {
+  return __y.base() - __x.base();
+}
+
+template <class _Iterator>
+inline reverse_iterator<_Iterator> 
+operator+(typename reverse_iterator<_Iterator>::difference_type __n,
+          const reverse_iterator<_Iterator>& __x) {
+  return reverse_iterator<_Iterator>(__x.base() - __n);
+}
+
+#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+// This is the old version of reverse_iterator, as found in the original
+//  HP STL.  It does not use partial specialization.
+
+#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
+template <class _RandomAccessIterator, class _Tp, class _Reference = _Tp&,
+          class _Distance = ptrdiff_t> 
+#else
+template <class _RandomAccessIterator, class _Tp, class _Reference,
+          class _Distance> 
+#endif
+class reverse_iterator {
+  typedef reverse_iterator<_RandomAccessIterator, _Tp, _Reference, _Distance>
+        _Self;
+protected:
+  _RandomAccessIterator current;
+public:
+  typedef random_access_iterator_tag iterator_category;
+  typedef _Tp                        value_type;
+  typedef _Distance                  difference_type;
+  typedef _Tp*                       pointer;
+  typedef _Reference                 reference;
+
+  reverse_iterator() {}
+  explicit reverse_iterator(_RandomAccessIterator __x) : current(__x) {}
+  _RandomAccessIterator base() const { return current; }
+  _Reference operator*() const { return *(current - 1); }
+#ifndef __SGI_STL_NO_ARROW_OPERATOR
+  pointer operator->() const { return &(operator*()); }
+#endif /* __SGI_STL_NO_ARROW_OPERATOR */
+  _Self& operator++() {
+    --current;
+    return *this;
+  }
+  _Self operator++(int) {
+    _Self __tmp = *this;
+    --current;
+    return __tmp;
+  }
+  _Self& operator--() {
+    ++current;
+    return *this;
+  }
+  _Self operator--(int) {
+    _Self __tmp = *this;
+    ++current;
+    return __tmp;
+  }
+  _Self operator+(_Distance __n) const {
+    return _Self(current - __n);
+  }
+  _Self& operator+=(_Distance __n) {
+    current -= __n;
+    return *this;
+  }
+  _Self operator-(_Distance __n) const {
+    return _Self(current + __n);
+  }
+  _Self& operator-=(_Distance __n) {
+    current += __n;
+    return *this;
+  }
+  _Reference operator[](_Distance __n) const { return *(*this + __n); }
+};
+
+template <class _RandomAccessIterator, class _Tp, 
+          class _Reference, class _Distance>
+inline random_access_iterator_tag
+iterator_category(const reverse_iterator<_RandomAccessIterator, _Tp,
+                                         _Reference, _Distance>&)
+{
+  return random_access_iterator_tag();
+}
+
+template <class _RandomAccessIterator, class _Tp,
+          class _Reference, class _Distance>
+inline _Tp* value_type(const reverse_iterator<_RandomAccessIterator, _Tp,
+                                              _Reference, _Distance>&)
+{
+  return (_Tp*) 0;
+}
+
+template <class _RandomAccessIterator, class _Tp,
+          class _Reference, class _Distance>
+inline _Distance* 
+distance_type(const reverse_iterator<_RandomAccessIterator, 
+                                     _Tp, _Reference, _Distance>&)
+{
+  return (_Distance*) 0;
+}
+
+
+template <class _RandomAccessIterator, class _Tp,
+          class _Reference, class _Distance>
+inline bool 
+operator==(const reverse_iterator<_RandomAccessIterator, _Tp,
+                                  _Reference, _Distance>& __x, 
+           const reverse_iterator<_RandomAccessIterator, _Tp,
+                                  _Reference, _Distance>& __y)
+{
+  return __x.base() == __y.base();
+}
+
+template <class _RandomAccessIterator, class _Tp,
+          class _Reference, class _Distance>
+inline bool 
+operator<(const reverse_iterator<_RandomAccessIterator, _Tp,
+                                 _Reference, _Distance>& __x, 
+          const reverse_iterator<_RandomAccessIterator, _Tp,
+                                 _Reference, _Distance>& __y)
+{
+  return __y.base() < __x.base();
+}
+
+template <class _RandomAccessIterator, class _Tp,
+          class _Reference, class _Distance>
+inline _Distance 
+operator-(const reverse_iterator<_RandomAccessIterator, _Tp,
+                                 _Reference, _Distance>& __x, 
+          const reverse_iterator<_RandomAccessIterator, _Tp,
+                                 _Reference, _Distance>& __y)
+{
+  return __y.base() - __x.base();
+}
+
+template <class _RandAccIter, class _Tp, class _Ref, class _Dist>
+inline reverse_iterator<_RandAccIter, _Tp, _Ref, _Dist> 
+operator+(_Dist __n,
+          const reverse_iterator<_RandAccIter, _Tp, _Ref, _Dist>& __x)
+{
+  return reverse_iterator<_RandAccIter, _Tp, _Ref, _Dist>(__x.base() - __n);
+}
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+// When we have templatized iostreams, istream_iterator and ostream_iterator
+// must be rewritten.
+
+template <class _Tp, class _Dist = ptrdiff_t> 
+class istream_iterator {
+  friend bool operator== __STL_NULL_TMPL_ARGS (const istream_iterator&,
+                                               const istream_iterator&);
+protected:
+  istream* _M_stream;
+  _Tp _M_value;
+  bool _M_end_marker;
+  void _M_read() {
+    _M_end_marker = (*_M_stream) ? true : false;
+    if (_M_end_marker) *_M_stream >> _M_value;
+    _M_end_marker = (*_M_stream) ? true : false;
+  }
+public:
+  typedef input_iterator_tag  iterator_category;
+  typedef _Tp                 value_type;
+  typedef _Dist               difference_type;
+  typedef const _Tp*          pointer;
+  typedef const _Tp&          reference;
+
+  istream_iterator() : _M_stream(&cin), _M_end_marker(false) {}
+  istream_iterator(istream& __s) : _M_stream(&__s) { _M_read(); }
+  reference operator*() const { return _M_value; }
+#ifndef __SGI_STL_NO_ARROW_OPERATOR
+  pointer operator->() const { return &(operator*()); }
+#endif /* __SGI_STL_NO_ARROW_OPERATOR */
+  istream_iterator<_Tp, _Dist>& operator++() { 
+    _M_read(); 
+    return *this;
+  }
+  istream_iterator<_Tp, _Dist> operator++(int)  {
+    istream_iterator<_Tp, _Dist> __tmp = *this;
+    _M_read();
+    return __tmp;
+  }
+};
+
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class _Tp, class _Dist>
+inline input_iterator_tag 
+iterator_category(const istream_iterator<_Tp, _Dist>&)
+{
+  return input_iterator_tag();
+}
+
+template <class _Tp, class _Dist>
+inline _Tp* 
+value_type(const istream_iterator<_Tp, _Dist>&) { return (_Tp*) 0; }
+
+template <class _Tp, class _Dist>
+inline _Dist* 
+distance_type(const istream_iterator<_Tp, _Dist>&) { return (_Dist*)0; }
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+template <class _Tp, class _Distance>
+inline bool operator==(const istream_iterator<_Tp, _Distance>& __x,
+                       const istream_iterator<_Tp, _Distance>& __y) {
+  return (__x._M_stream == __y._M_stream &&
+          __x._M_end_marker == __y._M_end_marker) ||
+         __x._M_end_marker == false && __y._M_end_marker == false;
+}
+
+template <class _Tp>
+class ostream_iterator {
+protected:
+  ostream* _M_stream;
+  const char* _M_string;
+public:
+  typedef output_iterator_tag iterator_category;
+  typedef void                value_type;
+  typedef void                difference_type;
+  typedef void                pointer;
+  typedef void                reference;
+
+  ostream_iterator(ostream& __s) : _M_stream(&__s), _M_string(0) {}
+  ostream_iterator(ostream& __s, const char* __c) 
+    : _M_stream(&__s), _M_string(__c)  {}
+  ostream_iterator<_Tp>& operator=(const _Tp& __value) { 
+    *_M_stream << __value;
+    if (_M_string) *_M_stream << _M_string;
+    return *this;
+  }
+  ostream_iterator<_Tp>& operator*() { return *this; }
+  ostream_iterator<_Tp>& operator++() { return *this; } 
+  ostream_iterator<_Tp>& operator++(int) { return *this; } 
+};
+
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class _Tp>
+inline output_iterator_tag 
+iterator_category(const ostream_iterator<_Tp>&) {
+  return output_iterator_tag();
+}
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_ITERATOR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_list.h b/gnu/egcs/libstdc++/stl/stl_list.h
new file mode 100644
index 00000000000..5d95d641e52
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_list.h
@@ -0,0 +1,840 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_LIST_H
+#define __SGI_STL_INTERNAL_LIST_H
+
+__STL_BEGIN_NAMESPACE
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1174
+#pragma set woff 1375
+#endif
+
+template <class _Tp>
+struct _List_node {
+  typedef void* _Void_pointer;
+  _Void_pointer _M_next;
+  _Void_pointer _M_prev;
+  _Tp _M_data;
+};
+
+template<class _Tp, class _Ref, class _Ptr>
+struct _List_iterator {
+  typedef _List_iterator<_Tp,_Tp&,_Tp*>             iterator;
+  typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
+  typedef _List_iterator<_Tp,_Ref,_Ptr>             _Self;
+
+  typedef bidirectional_iterator_tag iterator_category;
+  typedef _Tp value_type;
+  typedef _Ptr pointer;
+  typedef _Ref reference;
+  typedef _List_node<_Tp> _Node;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+
+  _Node* _M_node;
+
+  _List_iterator(_Node* __x) : _M_node(__x) {}
+  _List_iterator() {}
+  _List_iterator(const iterator& __x) : _M_node(__x._M_node) {}
+
+  bool operator==(const _Self& __x) const { return _M_node == __x._M_node; }
+  bool operator!=(const _Self& __x) const { return _M_node != __x._M_node; }
+  reference operator*() const { return (*_M_node)._M_data; }
+
+#ifndef __SGI_STL_NO_ARROW_OPERATOR
+  pointer operator->() const { return &(operator*()); }
+#endif /* __SGI_STL_NO_ARROW_OPERATOR */
+
+  _Self& operator++() { 
+    _M_node = (_Node*)(_M_node->_M_next);
+    return *this;
+  }
+  _Self operator++(int) { 
+    _Self __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
+  _Self& operator--() { 
+    _M_node = (_Node*)(_M_node->_M_prev);
+    return *this;
+  }
+  _Self operator--(int) { 
+    _Self __tmp = *this;
+    --*this;
+    return __tmp;
+  }
+};
+
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class _Tp, class _Ref, class _Ptr>
+inline bidirectional_iterator_tag
+iterator_category(const _List_iterator<_Tp, _Ref, _Ptr>&)
+{
+  return bidirectional_iterator_tag();
+}
+
+template <class _Tp, class _Ref, class _Ptr>
+inline _Tp*
+value_type(const _List_iterator<_Tp, _Ref, _Ptr>&)
+{
+  return 0;
+}
+
+template <class _Tp, class _Ref, class _Ptr>
+inline ptrdiff_t*
+distance_type(const _List_iterator<_Tp, _Ref, _Ptr>&)
+{
+  return 0;
+}
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+
+// Base class that encapsulates details of allocators.  Three cases:
+// an ordinary standard-conforming allocator, a standard-conforming
+// allocator with no non-static data, and an SGI-style allocator.
+// This complexity is necessary only because we're worrying about backward
+// compatibility and because we want to avoid wasting storage on an 
+// allocator instance if it isn't necessary.
+
+#ifdef __STL_USE_STD_ALLOCATORS
+
+// Base for general standard-conforming allocators.
+template <class _Tp, class _Allocator, bool _IsStatic>
+class _List_alloc_base {
+public:
+  typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
+          allocator_type;
+  allocator_type get_allocator() const { return _Node_allocator; }
+
+  _List_alloc_base(const allocator_type& __a) : _Node_allocator(__a) {}
+
+protected:
+  _List_node<_Tp>* _M_get_node()
+   { return _Node_allocator.allocate(1); }
+  void _M_put_node(_List_node<_Tp>* __p)
+    { _Node_allocator.deallocate(__p, 1); }
+
+protected:
+  typename _Alloc_traits<_List_node<_Tp>, _Allocator>::allocator_type
+           _Node_allocator;
+  _List_node<_Tp>* _M_node;
+};
+
+// Specialization for instanceless allocators.
+
+template <class _Tp, class _Allocator>
+class _List_alloc_base<_Tp, _Allocator, true> {
+public:
+  typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
+          allocator_type;
+  allocator_type get_allocator() const { return allocator_type(); }
+
+  _List_alloc_base(const allocator_type&) {}
+
+protected:
+  typedef typename _Alloc_traits<_List_node<_Tp>, _Allocator>::_Alloc_type
+          _Alloc_type;
+  _List_node<_Tp>* _M_get_node() { return _Alloc_type::allocate(1); }
+  void _M_put_node(_List_node<_Tp>* __p) { _Alloc_type::deallocate(__p, 1); }
+
+protected:
+  _List_node<_Tp>* _M_node;
+};
+
+template <class _Tp, class _Alloc>
+class _List_base 
+  : public _List_alloc_base<_Tp, _Alloc,
+                            _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
+{
+public:
+  typedef _List_alloc_base<_Tp, _Alloc,
+                           _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
+          _Base; 
+  typedef typename _Base::allocator_type allocator_type;
+
+  _List_base(const allocator_type& __a) : _Base(__a) {
+    _M_node = _M_get_node();
+    _M_node->_M_next = _M_node;
+    _M_node->_M_prev = _M_node;
+  }
+  ~_List_base() {
+    clear();
+    _M_put_node(_M_node);
+  }
+
+  void clear();
+};
+
+#else /* __STL_USE_STD_ALLOCATORS */
+
+template <class _Tp, class _Alloc>
+class _List_base 
+{
+public:
+  typedef _Alloc allocator_type;
+  allocator_type get_allocator() const { return allocator_type(); }
+
+  _List_base(const allocator_type&) {
+    _M_node = _M_get_node();
+    _M_node->_M_next = _M_node;
+    _M_node->_M_prev = _M_node;
+  }
+  ~_List_base() {
+    clear();
+    _M_put_node(_M_node);
+  }
+
+  void clear();
+
+protected:
+  typedef simple_alloc<_List_node<_Tp>, _Alloc> _Alloc_type;
+  _List_node<_Tp>* _M_get_node() { return _Alloc_type::allocate(1); }
+  void _M_put_node(_List_node<_Tp>* __p) { _Alloc_type::deallocate(__p, 1); } 
+
+protected:
+  _List_node<_Tp>* _M_node;
+};
+
+#endif /* __STL_USE_STD_ALLOCATORS */
+
+template <class _Tp, class _Alloc>
+void 
+_List_base<_Tp,_Alloc>::clear() 
+{
+  _List_node<_Tp>* __cur = (_List_node<_Tp>*) _M_node->_M_next;
+  while (__cur != _M_node) {
+    _List_node<_Tp>* __tmp = __cur;
+    __cur = (_List_node<_Tp>*) __cur->_M_next;
+    destroy(&__tmp->_M_data);
+    _M_put_node(__tmp);
+  }
+  _M_node->_M_next = _M_node;
+  _M_node->_M_prev = _M_node;
+}
+
+template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
+class list : protected _List_base<_Tp, _Alloc> {
+  typedef _List_base<_Tp, _Alloc> _Base;
+protected:
+  typedef void* _Void_pointer;
+
+public:      
+  typedef _Tp value_type;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef _List_node<_Tp> _Node;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+
+  typedef typename _Base::allocator_type allocator_type;
+  allocator_type get_allocator() const { return _Base::get_allocator(); }
+
+public:
+  typedef _List_iterator<_Tp,_Tp&,_Tp*>             iterator;
+  typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+  typedef reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef reverse_iterator<iterator>       reverse_iterator;
+#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+  typedef reverse_bidirectional_iterator<const_iterator,value_type,
+                                         const_reference,difference_type>
+          const_reverse_iterator;
+  typedef reverse_bidirectional_iterator<iterator,value_type,reference,
+                                         difference_type>
+          reverse_iterator; 
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+protected:
+#ifdef __STL_HAS_NAMESPACES
+  using _Base::_M_node;
+  using _Base::_M_put_node;
+  using _Base::_M_get_node;
+#endif /* __STL_HAS_NAMESPACES */
+
+protected:
+  _Node* _M_create_node(const _Tp& __x)
+  {
+    _Node* __p = _M_get_node();
+    __STL_TRY {
+      construct(&__p->_M_data, __x);
+    }
+    __STL_UNWIND(_M_put_node(__p));
+    return __p;
+  }
+
+  _Node* _M_create_node()
+  {
+    _Node* __p = _M_get_node();
+    __STL_TRY {
+      construct(&__p->_M_data);
+    }
+    __STL_UNWIND(_M_put_node(__p));
+    return __p;
+  }
+
+public:
+  explicit list(const allocator_type& __a = allocator_type()) : _Base(__a) {}
+
+  iterator begin()             { return (_Node*)(_M_node->_M_next); }
+  const_iterator begin() const { return (_Node*)(_M_node->_M_next); }
+
+  iterator end()             { return _M_node; }
+  const_iterator end() const { return _M_node; }
+
+  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()); }
+
+  bool empty() const { return _M_node->_M_next == _M_node; }
+  size_type size() const {
+    size_type __result = 0;
+    distance(begin(), end(), __result);
+    return __result;
+  }
+  size_type max_size() const { return size_type(-1); }
+
+  reference front() { return *begin(); }
+  const_reference front() const { return *begin(); }
+  reference back() { return *(--end()); }
+  const_reference back() const { return *(--end()); }
+
+  void swap(list<_Tp, _Alloc>& __x) { __STD::swap(_M_node, __x._M_node); }
+
+  iterator insert(iterator __position, const _Tp& __x) {
+    _Node* __tmp = _M_create_node(__x);
+    __tmp->_M_next = __position._M_node;
+    __tmp->_M_prev = __position._M_node->_M_prev;
+    ((_Node*) (__position._M_node->_M_prev))->_M_next = __tmp;
+    __position._M_node->_M_prev = __tmp;
+    return __tmp;
+  }
+  iterator insert(iterator __position) { return insert(__position, _Tp()); }
+#ifdef __STL_MEMBER_TEMPLATES
+  // Check whether it's an integral type.  If so, it's not an iterator.
+
+  template<class _Integer>
+  void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
+                          __true_type) {
+    insert(__pos, (size_type) __n, (_Tp) __x);
+  }
+
+  template <class _InputIterator>
+  void _M_insert_dispatch(iterator __pos,
+                          _InputIterator __first, _InputIterator __last,
+                          __false_type);
+
+  template <class _InputIterator>
+  void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
+    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
+    _M_insert_dispatch(__pos, __first, __last, _Integral());
+  }
+
+#else /* __STL_MEMBER_TEMPLATES */
+  void insert(iterator __position, const _Tp* __first, const _Tp* __last);
+  void insert(iterator __position,
+              const_iterator __first, const_iterator __last);
+#endif /* __STL_MEMBER_TEMPLATES */
+  void insert(iterator __pos, size_type __n, const _Tp& __x);
+ 
+  void push_front(const _Tp& __x) { insert(begin(), __x); }
+  void push_front() {insert(begin());}
+  void push_back(const _Tp& __x) { insert(end(), __x); }
+  void push_back() {insert(end());}
+
+  iterator erase(iterator __position) {
+    _Node* __next_node = (_Node*) (__position._M_node->_M_next);
+    _Node* __prev_node = (_Node*) (__position._M_node->_M_prev);
+    __prev_node->_M_next = __next_node;
+    __next_node->_M_prev = __prev_node;
+    destroy(&__position._M_node->_M_data);
+    _M_put_node(__position._M_node);
+    return iterator(__next_node);
+  }
+  iterator erase(iterator __first, iterator __last);
+  void clear() { _Base::clear(); }
+
+  void resize(size_type __new_size, const _Tp& __x);
+  void resize(size_type __new_size) { resize(__new_size, _Tp()); }
+
+  void pop_front() { erase(begin()); }
+  void pop_back() { 
+    iterator __tmp = end();
+    erase(--__tmp);
+  }
+  list(size_type __n, const _Tp& __value,
+       const allocator_type& __a = allocator_type())
+    : _Base(__a)
+    { insert(begin(), __n, __value); }
+  explicit list(size_type __n)
+    : _Base(allocator_type())
+    { insert(begin(), __n, _Tp()); }
+
+#ifdef __STL_MEMBER_TEMPLATES
+
+  // We don't need any dispatching tricks here, because insert does all of
+  // that anyway.  
+  template <class _InputIterator>
+  list(_InputIterator __first, _InputIterator __last,
+       const allocator_type& __a = allocator_type())
+    : _Base(__a)
+    { insert(begin(), __first, __last); }
+
+#else /* __STL_MEMBER_TEMPLATES */
+
+  list(const _Tp* __first, const _Tp* __last,
+       const allocator_type& __a = allocator_type())
+    : _Base(__a)
+    { insert(begin(), __first, __last); }
+  list(const_iterator __first, const_iterator __last,
+       const allocator_type& __a = allocator_type())
+    : _Base(__a)
+    { insert(begin(), __first, __last); }
+
+#endif /* __STL_MEMBER_TEMPLATES */
+  list(const list<_Tp, _Alloc>& __x) : _Base(__x.get_allocator())
+    { insert(begin(), __x.begin(), __x.end()); }
+
+  ~list() { }
+
+  list<_Tp, _Alloc>& operator=(const list<_Tp, _Alloc>& __x);
+
+public:
+  // assign(), a generalized assignment member function.  Two
+  // versions: one that takes a count, and one that takes a range.
+  // The range version is a member template, so we dispatch on whether
+  // or not the type is an integer.
+
+  void assign(size_type __n, const _Tp& __val);
+
+#ifdef __STL_MEMBER_TEMPLATES
+
+  template <class _InputIterator>
+  void assign(_InputIterator __first, _InputIterator __last) {
+    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
+    _M_assign_dispatch(__first, __last, _Integral());
+  }
+
+  template <class _Integer>
+  void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+    { assign((size_type) __n, (_Tp) __val); }
+
+  template <class _InputIterator>
+  void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+                          __false_type);
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+protected:
+  void transfer(iterator __position, iterator __first, iterator __last) {
+    if (__position != __last) {
+      // Remove [first, last) from its old position.
+      ((_Node*) (__last._M_node->_M_prev))->_M_next     = __position._M_node;
+      ((_Node*) (__first._M_node->_M_prev))->_M_next    = __last._M_node;
+      ((_Node*) (__position._M_node->_M_prev))->_M_next = __first._M_node; 
+
+      // Splice [first, last) into its new position.
+      _Node* __tmp = (_Node*) (__position._M_node->_M_prev);
+      __position._M_node->_M_prev = __last._M_node->_M_prev;
+      __last._M_node->_M_prev      = __first._M_node->_M_prev; 
+      __first._M_node->_M_prev    = __tmp;
+    }
+  }
+
+public:
+  void splice(iterator __position, list& __x) {
+    if (!__x.empty()) 
+      transfer(__position, __x.begin(), __x.end());
+  }
+  void splice(iterator __position, list&, iterator __i) {
+    iterator __j = __i;
+    ++__j;
+    if (__position == __i || __position == __j) return;
+    transfer(__position, __i, __j);
+  }
+  void splice(iterator __position, list&, iterator __first, iterator __last) {
+    if (__first != __last) 
+      transfer(__position, __first, __last);
+  }
+  void remove(const _Tp& __value);
+  void unique();
+  void merge(list& __x);
+  void reverse();
+  void sort();
+
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _Predicate> void remove_if(_Predicate);
+  template <class _BinaryPredicate> void unique(_BinaryPredicate);
+  template <class _StrictWeakOrdering> void merge(list&, _StrictWeakOrdering);
+  template <class _StrictWeakOrdering> void sort(_StrictWeakOrdering);
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  friend bool operator== __STL_NULL_TMPL_ARGS (
+    const list& __x, const list& __y);
+};
+
+template <class _Tp, class _Alloc>
+inline bool operator==(const list<_Tp,_Alloc>& __x,
+                       const list<_Tp,_Alloc>& __y)
+{
+  typedef typename list<_Tp,_Alloc>::_Node _Node;
+  _Node* __e1 = __x._M_node;
+  _Node* __e2 = __y._M_node;
+  _Node* __n1 = (_Node*) __e1->_M_next;
+  _Node* __n2 = (_Node*) __e2->_M_next;
+  for ( ; __n1 != __e1 && __n2 != __e2 ;
+          __n1 = (_Node*) __n1->_M_next, __n2 = (_Node*) __n2->_M_next)
+    if (__n1->_M_data != __n2->_M_data)
+      return false;
+  return __n1 == __e1 && __n2 == __e2;
+}
+
+template <class _Tp, class _Alloc>
+inline bool operator<(const list<_Tp,_Alloc>& __x,
+                      const list<_Tp,_Alloc>& __y)
+{
+  return lexicographical_compare(__x.begin(), __x.end(),
+                                 __y.begin(), __y.end());
+}
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+
+template <class _Tp, class _Alloc>
+inline void 
+swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
+{
+  __x.swap(__y);
+}
+
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+#ifdef __STL_MEMBER_TEMPLATES
+
+template <class _Tp, class _Alloc> template <class _InputIter>
+void 
+list<_Tp, _Alloc>::_M_insert_dispatch(iterator __position,
+                                      _InputIter __first, _InputIter __last,
+                                      __false_type)
+{
+  for ( ; __first != __last; ++__first)
+    insert(__position, *__first);
+}
+
+#else /* __STL_MEMBER_TEMPLATES */
+
+template <class _Tp, class _Alloc>
+void 
+list<_Tp, _Alloc>::insert(iterator __position, 
+                          const _Tp* __first, const _Tp* __last)
+{
+  for ( ; __first != __last; ++__first)
+    insert(__position, *__first);
+}
+
+template <class _Tp, class _Alloc>
+void 
+list<_Tp, _Alloc>::insert(iterator __position,
+                         const_iterator __first, const_iterator __last)
+{
+  for ( ; __first != __last; ++__first)
+    insert(__position, *__first);
+}
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+template <class _Tp, class _Alloc>
+void 
+list<_Tp, _Alloc>::insert(iterator __position, size_type __n, const _Tp& __x)
+{
+  for ( ; __n > 0; --__n)
+    insert(__position, __x);
+}
+
+template <class _Tp, class _Alloc>
+list<_Tp,_Alloc>::iterator list<_Tp, _Alloc>::erase(iterator __first, 
+                                                    iterator __last)
+{
+  while (__first != __last)
+    erase(__first++);
+  return __last;
+}
+
+template <class _Tp, class _Alloc>
+void list<_Tp, _Alloc>::resize(size_type __new_size, const _Tp& __x)
+{
+  iterator __i = begin();
+  size_type __len = 0;
+  for ( ; __i != end() && __len < __new_size; ++__i, ++__len)
+    ;
+  if (__len == __new_size)
+    erase(__i, end());
+  else                          // __i == end()
+    insert(end(), __new_size - __len, __x);
+}
+
+template <class _Tp, class _Alloc>
+list<_Tp, _Alloc>& list<_Tp, _Alloc>::operator=(const list<_Tp, _Alloc>& __x)
+{
+  if (this != &__x) {
+    iterator __first1 = begin();
+    iterator __last1 = end();
+    const_iterator __first2 = __x.begin();
+    const_iterator __last2 = __x.end();
+    while (__first1 != __last1 && __first2 != __last2) 
+      *__first1++ = *__first2++;
+    if (__first2 == __last2)
+      erase(__first1, __last1);
+    else
+      insert(__last1, __first2, __last2);
+  }
+  return *this;
+}
+
+template <class _Tp, class _Alloc>
+void list<_Tp, _Alloc>::assign(size_type __n, const _Tp& __val) {
+  iterator __i = begin();
+  for ( ; __i != end() && __n > 0; ++__i, --__n)
+    *__i = __val;
+  if (__n > 0)
+    insert(end(), __n, __val);
+  else
+    erase(__i, end());
+}
+
+#ifdef __STL_MEMBER_TEMPLATES
+
+template <class _Tp, class _Alloc> template <class _InputIter>
+void
+list<_Tp, _Alloc>::_M_assign_dispatch(_InputIter __first2, _InputIter __last2,
+                                      __false_type)
+{
+  iterator __first1 = begin();
+  iterator __last1 = end();
+  for ( ; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)
+    *__first1 = *__first2;
+  if (__first2 == __last2)
+    erase(__first1, __last1);
+  else
+    insert(__last1, __first2, __last2);
+}
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+template <class _Tp, class _Alloc>
+void list<_Tp, _Alloc>::remove(const _Tp& __value)
+{
+  iterator __first = begin();
+  iterator __last = end();
+  while (__first != __last) {
+    iterator __next = __first;
+    ++__next;
+    if (*__first == __value) erase(__first);
+    __first = __next;
+  }
+}
+
+template <class _Tp, class _Alloc>
+void list<_Tp, _Alloc>::unique()
+{
+  iterator __first = begin();
+  iterator __last = end();
+  if (__first == __last) return;
+  iterator __next = __first;
+  while (++__next != __last) {
+    if (*__first == *__next)
+      erase(__next);
+    else
+      __first = __next;
+    __next = __first;
+  }
+}
+
+template <class _Tp, class _Alloc>
+void list<_Tp, _Alloc>::merge(list<_Tp, _Alloc>& __x)
+{
+  iterator __first1 = begin();
+  iterator __last1 = end();
+  iterator __first2 = __x.begin();
+  iterator __last2 = __x.end();
+  while (__first1 != __last1 && __first2 != __last2)
+    if (*__first2 < *__first1) {
+      iterator __next = __first2;
+      transfer(__first1, __first2, ++__next);
+      __first2 = __next;
+    }
+    else
+      ++__first1;
+  if (__first2 != __last2) transfer(__last1, __first2, __last2);
+}
+
+template <class _Tp, class _Alloc>
+void list<_Tp, _Alloc>::reverse() 
+{
+  // Do nothing if the list has length 0 or 1.
+  if (_M_node->_M_next != _M_node &&
+      ((_Node*) (_M_node->_M_next))->_M_next != _M_node) {
+    iterator __first = begin();
+    ++__first;
+    while (__first != end()) {
+      iterator __old = __first;
+      ++__first;
+      transfer(begin(), __old, __first);
+    }
+  }
+}    
+
+template <class _Tp, class _Alloc>
+void list<_Tp, _Alloc>::sort()
+{
+  // Do nothing if the list has length 0 or 1.
+  if (_M_node->_M_next != _M_node &&
+      ((_Node*) (_M_node->_M_next))->_M_next != _M_node) {
+    list<_Tp, _Alloc> __carry;
+    list<_Tp, _Alloc> __counter[64];
+    int __fill = 0;
+    while (!empty()) {
+      __carry.splice(__carry.begin(), *this, begin());
+      int __i = 0;
+      while(__i < __fill && !__counter[__i].empty()) {
+        __counter[__i].merge(__carry);
+        __carry.swap(__counter[__i++]);
+      }
+      __carry.swap(__counter[__i]);         
+      if (__i == __fill) ++__fill;
+    } 
+
+    for (int __i = 1; __i < __fill; ++__i)
+      __counter[__i].merge(__counter[__i-1]);
+    swap(__counter[__fill-1]);
+  }
+}
+
+#ifdef __STL_MEMBER_TEMPLATES
+
+template <class _Tp, class _Alloc> template <class _Predicate>
+void list<_Tp, _Alloc>::remove_if(_Predicate __pred)
+{
+  iterator __first = begin();
+  iterator __last = end();
+  while (__first != __last) {
+    iterator __next = __first;
+    ++__next;
+    if (__pred(*__first)) erase(__first);
+    __first = __next;
+  }
+}
+
+template <class _Tp, class _Alloc> template <class _BinaryPredicate>
+void list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred)
+{
+  iterator __first = begin();
+  iterator __last = end();
+  if (__first == __last) return;
+  iterator __next = __first;
+  while (++__next != __last) {
+    if (__binary_pred(*__first, *__next))
+      erase(__next);
+    else
+      __first = __next;
+    __next = __first;
+  }
+}
+
+template <class _Tp, class _Alloc> template <class _StrictWeakOrdering>
+void list<_Tp, _Alloc>::merge(list<_Tp, _Alloc>& __x,
+                              _StrictWeakOrdering __comp)
+{
+  iterator __first1 = begin();
+  iterator __last1 = end();
+  iterator __first2 = __x.begin();
+  iterator __last2 = __x.end();
+  while (__first1 != __last1 && __first2 != __last2)
+    if (__comp(*__first2, *__first1)) {
+      iterator __next = __first2;
+      transfer(__first1, __first2, ++__next);
+      __first2 = __next;
+    }
+    else
+      ++__first1;
+  if (__first2 != __last2) transfer(__last1, __first2, __last2);
+}
+
+template <class _Tp, class _Alloc> template <class _StrictWeakOrdering>
+void list<_Tp, _Alloc>::sort(_StrictWeakOrdering __comp)
+{
+  // Do nothing if the list has length 0 or 1.
+  if (_M_node->_M_next != _M_node &&
+      ((_Node*) (_M_node->_M_next))->_M_next != _M_node) {
+    list<_Tp, _Alloc> __carry;
+    list<_Tp, _Alloc> __counter[64];
+    int __fill = 0;
+    while (!empty()) {
+      __carry.splice(__carry.begin(), *this, begin());
+      int __i = 0;
+      while(__i < __fill && !__counter[__i].empty()) {
+        __counter[__i].merge(__carry, __comp);
+        __carry.swap(__counter[__i++]);
+      }
+      __carry.swap(__counter[__i]);         
+      if (__i == __fill) ++__fill;
+    } 
+
+    for (int __i = 1; __i < __fill; ++__i) 
+      __counter[__i].merge(__counter[__i-1], __comp);
+    swap(__counter[__fill-1]);
+  }
+}
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1174
+#pragma reset woff 1375
+#endif
+
+__STL_END_NAMESPACE 
+
+#endif /* __SGI_STL_INTERNAL_LIST_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_map.h b/gnu/egcs/libstdc++/stl/stl_map.h
new file mode 100644
index 00000000000..a702e8023ef
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_map.h
@@ -0,0 +1,242 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_MAP_H
+#define __SGI_STL_INTERNAL_MAP_H
+
+__STL_BEGIN_NAMESPACE
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1174
+#pragma set woff 1375
+#endif
+
+#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
+template <class _Key, class _Tp, class _Compare = less<_Key>,
+          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
+#else
+template <class _Key, class _Tp, class _Compare,
+          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
+#endif
+class map {
+public:
+
+// typedefs:
+
+  typedef _Key                  key_type;
+  typedef _Tp                   data_type;
+  typedef _Tp                   mapped_type;
+  typedef pair<const _Key, _Tp> value_type;
+  typedef _Compare              key_compare;
+    
+  class value_compare
+    : public binary_function<value_type, value_type, bool> {
+  friend class map<_Key,_Tp,_Compare,_Alloc>;
+  protected :
+    _Compare _M_comp;
+    value_compare(_Compare __c) : _M_comp(__c) {}
+  public:
+    bool operator()(const value_type& __x, const value_type& __y) const {
+      return _M_comp(__x.first, __y.first);
+    }
+  };
+
+private:
+  typedef _Rb_tree<key_type, value_type, 
+                   _Select1st<value_type>, key_compare, _Alloc> _Rep_type;
+  _Rep_type _M_t;  // red-black tree representing map
+public:
+  typedef typename _Rep_type::pointer pointer;
+  typedef typename _Rep_type::const_pointer const_pointer;
+  typedef typename _Rep_type::reference reference;
+  typedef typename _Rep_type::const_reference const_reference;
+  typedef typename _Rep_type::iterator iterator;
+  typedef typename _Rep_type::const_iterator const_iterator;
+  typedef typename _Rep_type::reverse_iterator reverse_iterator;
+  typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+  typedef typename _Rep_type::size_type size_type;
+  typedef typename _Rep_type::difference_type difference_type;
+  typedef typename _Rep_type::allocator_type allocator_type;
+
+  // allocation/deallocation
+
+  map() : _M_t(_Compare(), allocator_type()) {}
+  explicit map(const _Compare& __comp,
+               const allocator_type& __a = allocator_type())
+    : _M_t(__comp, __a) {}
+
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  map(_InputIterator __first, _InputIterator __last)
+    : _M_t(_Compare(), allocator_type())
+    { _M_t.insert_unique(__first, __last); }
+
+  template <class _InputIterator>
+  map(_InputIterator __first, _InputIterator __last, const _Compare& __comp,
+      const allocator_type& __a = allocator_type())
+    : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); }
+#else
+  map(const value_type* __first, const value_type* __last)
+    : _M_t(_Compare(), allocator_type())
+    { _M_t.insert_unique(__first, __last); }
+
+  map(const value_type* __first,
+      const value_type* __last, const _Compare& __comp,
+      const allocator_type& __a = allocator_type())
+    : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); }
+
+  map(const_iterator __first, const_iterator __last)
+    : _M_t(_Compare(), allocator_type()) 
+    { _M_t.insert_unique(__first, __last); }
+
+  map(const_iterator __first, const_iterator __last, const _Compare& __comp,
+      const allocator_type& __a = allocator_type())
+    : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); }
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  map(const map<_Key,_Tp,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {}
+  map<_Key,_Tp,_Compare,_Alloc>&
+  operator=(const map<_Key, _Tp, _Compare, _Alloc>& __x)
+  {
+    _M_t = __x._M_t;
+    return *this; 
+  }
+
+  // accessors:
+
+  key_compare key_comp() const { return _M_t.key_comp(); }
+  value_compare value_comp() const { return value_compare(_M_t.key_comp()); }
+  allocator_type get_allocator() const { return _M_t.get_allocator(); }
+
+  iterator begin() { return _M_t.begin(); }
+  const_iterator begin() const { return _M_t.begin(); }
+  iterator end() { return _M_t.end(); }
+  const_iterator end() const { return _M_t.end(); }
+  reverse_iterator rbegin() { return _M_t.rbegin(); }
+  const_reverse_iterator rbegin() const { return _M_t.rbegin(); }
+  reverse_iterator rend() { return _M_t.rend(); }
+  const_reverse_iterator rend() const { return _M_t.rend(); }
+  bool empty() const { return _M_t.empty(); }
+  size_type size() const { return _M_t.size(); }
+  size_type max_size() const { return _M_t.max_size(); }
+  _Tp& operator[](const key_type& __k) {
+    iterator __i = lower_bound(__k);
+    // __i->first is greater than or equivalent to __k.
+    if (__i == end() || key_comp()(__k, (*__i).first))
+      __i = insert(__i, value_type(__k, _Tp()));
+    return (*__i).second;
+  }
+  void swap(map<_Key,_Tp,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }
+
+  // insert/erase
+
+  pair<iterator,bool> insert(const value_type& __x) 
+    { return _M_t.insert_unique(__x); }
+  iterator insert(iterator position, const value_type& __x)
+    { return _M_t.insert_unique(position, __x); }
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  void insert(_InputIterator __first, _InputIterator __last) {
+    _M_t.insert_unique(__first, __last);
+  }
+#else
+  void insert(const value_type* __first, const value_type* __last) {
+    _M_t.insert_unique(__first, __last);
+  }
+  void insert(const_iterator __first, const_iterator __last) {
+    _M_t.insert_unique(__first, __last);
+  }
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  void erase(iterator __position) { _M_t.erase(__position); }
+  size_type erase(const key_type& __x) { return _M_t.erase(__x); }
+  void erase(iterator __first, iterator __last)
+    { _M_t.erase(__first, __last); }
+  void clear() { _M_t.clear(); }
+
+  // map operations:
+
+  iterator find(const key_type& __x) { return _M_t.find(__x); }
+  const_iterator find(const key_type& __x) const { return _M_t.find(__x); }
+  size_type count(const key_type& __x) const { return _M_t.count(__x); }
+  iterator lower_bound(const key_type& __x) {return _M_t.lower_bound(__x); }
+  const_iterator lower_bound(const key_type& __x) const {
+    return _M_t.lower_bound(__x); 
+  }
+  iterator upper_bound(const key_type& __x) {return _M_t.upper_bound(__x); }
+  const_iterator upper_bound(const key_type& __x) const {
+    return _M_t.upper_bound(__x); 
+  }
+  
+  pair<iterator,iterator> equal_range(const key_type& __x) {
+    return _M_t.equal_range(__x);
+  }
+  pair<const_iterator,const_iterator> equal_range(const key_type& __x) const {
+    return _M_t.equal_range(__x);
+  }
+  friend bool operator== __STL_NULL_TMPL_ARGS (const map&, const map&);
+  friend bool operator< __STL_NULL_TMPL_ARGS (const map&, const map&);
+};
+
+template <class _Key, class _Tp, class _Compare, class _Alloc>
+inline bool operator==(const map<_Key,_Tp,_Compare,_Alloc>& __x, 
+                       const map<_Key,_Tp,_Compare,_Alloc>& __y) {
+  return __x._M_t == __y._M_t;
+}
+
+template <class _Key, class _Tp, class _Compare, class _Alloc>
+inline bool operator<(const map<_Key,_Tp,_Compare,_Alloc>& __x, 
+                      const map<_Key,_Tp,_Compare,_Alloc>& __y) {
+  return __x._M_t < __y._M_t;
+}
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+
+template <class _Key, class _Tp, class _Compare, class _Alloc>
+inline void swap(map<_Key,_Tp,_Compare,_Alloc>& __x, 
+                 map<_Key,_Tp,_Compare,_Alloc>& __y) {
+  __x.swap(__y);
+}
+
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1174
+#pragma reset woff 1375
+#endif
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_MAP_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_multimap.h b/gnu/egcs/libstdc++/stl/stl_multimap.h
new file mode 100644
index 00000000000..b7d3b87e52d
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_multimap.h
@@ -0,0 +1,232 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_MULTIMAP_H
+#define __SGI_STL_INTERNAL_MULTIMAP_H
+
+__STL_BEGIN_NAMESPACE
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1174
+#pragma set woff 1375
+#endif
+
+#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
+template <class _Key, class _Tp, class _Compare = less<_Key>,
+          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
+#else
+template <class _Key, class _Tp, class _Compare,
+          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
+#endif
+class multimap {
+public:
+
+// typedefs:
+
+  typedef _Key                  key_type;
+  typedef _Tp                   data_type;
+  typedef _Tp                   mapped_type;
+  typedef pair<const _Key, _Tp> value_type;
+  typedef _Compare              key_compare;
+
+  class value_compare : public binary_function<value_type, value_type, bool> {
+  friend class multimap<_Key,_Tp,_Compare,_Alloc>;
+  protected:
+    _Compare _M_comp;
+    value_compare(_Compare __c) : _M_comp(__c) {}
+  public:
+    bool operator()(const value_type& __x, const value_type& __y) const {
+      return _M_comp(__x.first, __y.first);
+    }
+  };
+
+private:
+  typedef _Rb_tree<key_type, value_type, 
+                  _Select1st<value_type>, key_compare, _Alloc> _Rep_type;
+  _Rep_type _M_t;  // red-black tree representing multimap
+public:
+  typedef typename _Rep_type::pointer pointer;
+  typedef typename _Rep_type::const_pointer const_pointer;
+  typedef typename _Rep_type::reference reference;
+  typedef typename _Rep_type::const_reference const_reference;
+  typedef typename _Rep_type::iterator iterator;
+  typedef typename _Rep_type::const_iterator const_iterator; 
+  typedef typename _Rep_type::reverse_iterator reverse_iterator;
+  typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+  typedef typename _Rep_type::size_type size_type;
+  typedef typename _Rep_type::difference_type difference_type;
+  typedef typename _Rep_type::allocator_type allocator_type;
+
+// allocation/deallocation
+
+  multimap() : _M_t(_Compare(), allocator_type()) { }
+  explicit multimap(const _Compare& __comp,
+                    const allocator_type& __a = allocator_type())
+    : _M_t(__comp, __a) { }
+
+#ifdef __STL_MEMBER_TEMPLATES  
+  template <class _InputIterator>
+  multimap(_InputIterator __first, _InputIterator __last)
+    : _M_t(_Compare(), allocator_type())
+    { _M_t.insert_equal(__first, __last); }
+
+  template <class _InputIterator>
+  multimap(_InputIterator __first, _InputIterator __last,
+           const _Compare& __comp,
+           const allocator_type& __a = allocator_type())
+    : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
+#else
+  multimap(const value_type* __first, const value_type* __last)
+    : _M_t(_Compare(), allocator_type())
+    { _M_t.insert_equal(__first, __last); }
+  multimap(const value_type* __first, const value_type* __last,
+           const _Compare& __comp,
+           const allocator_type& __a = allocator_type())
+    : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
+
+  multimap(const_iterator __first, const_iterator __last)
+    : _M_t(_Compare(), allocator_type())
+    { _M_t.insert_equal(__first, __last); }
+  multimap(const_iterator __first, const_iterator __last,
+           const _Compare& __comp,
+           const allocator_type& __a = allocator_type())
+    : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  multimap(const multimap<_Key,_Tp,_Compare,_Alloc>& __x) : _M_t(__x._M_t) { }
+  multimap<_Key,_Tp,_Compare,_Alloc>&
+  operator=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x) {
+    _M_t = __x._M_t;
+    return *this; 
+  }
+
+  // accessors:
+
+  key_compare key_comp() const { return _M_t.key_comp(); }
+  value_compare value_comp() const { return value_compare(_M_t.key_comp()); }
+  allocator_type get_allocator() const { return _M_t.get_allocator(); }
+
+  iterator begin() { return _M_t.begin(); }
+  const_iterator begin() const { return _M_t.begin(); }
+  iterator end() { return _M_t.end(); }
+  const_iterator end() const { return _M_t.end(); }
+  reverse_iterator rbegin() { return _M_t.rbegin(); }
+  const_reverse_iterator rbegin() const { return _M_t.rbegin(); }
+  reverse_iterator rend() { return _M_t.rend(); }
+  const_reverse_iterator rend() const { return _M_t.rend(); }
+  bool empty() const { return _M_t.empty(); }
+  size_type size() const { return _M_t.size(); }
+  size_type max_size() const { return _M_t.max_size(); }
+  void swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }
+
+  // insert/erase
+
+  iterator insert(const value_type& __x) { return _M_t.insert_equal(__x); }
+  iterator insert(iterator __position, const value_type& __x) {
+    return _M_t.insert_equal(__position, __x);
+  }
+#ifdef __STL_MEMBER_TEMPLATES  
+  template <class _InputIterator>
+  void insert(_InputIterator __first, _InputIterator __last) {
+    _M_t.insert_equal(__first, __last);
+  }
+#else
+  void insert(const value_type* __first, const value_type* __last) {
+    _M_t.insert_equal(__first, __last);
+  }
+  void insert(const_iterator __first, const_iterator __last) {
+    _M_t.insert_equal(__first, __last);
+  }
+#endif /* __STL_MEMBER_TEMPLATES */
+  void erase(iterator __position) { _M_t.erase(__position); }
+  size_type erase(const key_type& __x) { return _M_t.erase(__x); }
+  void erase(iterator __first, iterator __last)
+    { _M_t.erase(__first, __last); }
+  void clear() { _M_t.clear(); }
+
+  // multimap operations:
+
+  iterator find(const key_type& __x) { return _M_t.find(__x); }
+  const_iterator find(const key_type& __x) const { return _M_t.find(__x); }
+  size_type count(const key_type& __x) const { return _M_t.count(__x); }
+  iterator lower_bound(const key_type& __x) {return _M_t.lower_bound(__x); }
+  const_iterator lower_bound(const key_type& __x) const {
+    return _M_t.lower_bound(__x); 
+  }
+  iterator upper_bound(const key_type& __x) {return _M_t.upper_bound(__x); }
+  const_iterator upper_bound(const key_type& __x) const {
+    return _M_t.upper_bound(__x); 
+  }
+   pair<iterator,iterator> equal_range(const key_type& __x) {
+    return _M_t.equal_range(__x);
+  }
+  pair<const_iterator,const_iterator> equal_range(const key_type& __x) const {
+    return _M_t.equal_range(__x);
+  }
+  friend bool operator== __STL_NULL_TMPL_ARGS (const multimap&,
+                                               const multimap&);
+  friend bool operator< __STL_NULL_TMPL_ARGS (const multimap&,
+                                              const multimap&);
+};
+
+template <class _Key, class _Tp, class _Compare, class _Alloc>
+inline bool operator==(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, 
+                       const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
+  return __x._M_t == __y._M_t;
+}
+
+template <class _Key, class _Tp, class _Compare, class _Alloc>
+inline bool operator<(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, 
+                      const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
+  return __x._M_t < __y._M_t;
+}
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+
+template <class _Key, class _Tp, class _Compare, class _Alloc>
+inline void swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x, 
+                 multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
+  __x.swap(__y);
+}
+
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1174
+#pragma reset woff 1375
+#endif
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_MULTIMAP_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_multiset.h b/gnu/egcs/libstdc++/stl/stl_multiset.h
new file mode 100644
index 00000000000..7378e43f8b3
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_multiset.h
@@ -0,0 +1,224 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_MULTISET_H
+#define __SGI_STL_INTERNAL_MULTISET_H
+
+__STL_BEGIN_NAMESPACE
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1174
+#pragma set woff 1375
+#endif
+
+#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
+template <class _Key, class _Compare = less<_Key>, 
+          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Key) >
+#else
+template <class _Key, class _Compare, 
+          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Key) >
+#endif
+class multiset {
+public:
+  // typedefs:
+
+  typedef _Key     key_type;
+  typedef _Key     value_type;
+  typedef _Compare key_compare;
+  typedef _Compare value_compare;
+private:
+  typedef _Rb_tree<key_type, value_type, 
+                  _Identity<value_type>, key_compare, _Alloc> _Rep_type;
+  _Rep_type _M_t;  // red-black tree representing multiset
+public:
+  typedef typename _Rep_type::const_pointer pointer;
+  typedef typename _Rep_type::const_pointer const_pointer;
+  typedef typename _Rep_type::const_reference reference;
+  typedef typename _Rep_type::const_reference const_reference;
+  typedef typename _Rep_type::const_iterator iterator;
+  typedef typename _Rep_type::const_iterator const_iterator;
+  typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
+  typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+  typedef typename _Rep_type::size_type size_type;
+  typedef typename _Rep_type::difference_type difference_type;
+  typedef typename _Rep_type::allocator_type allocator_type;
+
+  // allocation/deallocation
+
+  multiset() : _M_t(_Compare(), allocator_type()) {}
+  explicit multiset(const _Compare& __comp,
+                    const allocator_type& __a = allocator_type())
+    : _M_t(__comp, __a) {}
+
+#ifdef __STL_MEMBER_TEMPLATES
+
+  template <class _InputIterator>
+  multiset(_InputIterator __first, _InputIterator __last)
+    : _M_t(_Compare(), allocator_type())
+    { _M_t.insert_equal(__first, __last); }
+
+  template <class _InputIterator>
+  multiset(_InputIterator __first, _InputIterator __last,
+           const _Compare& __comp,
+           const allocator_type& __a = allocator_type())
+    : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
+
+#else
+
+  multiset(const value_type* __first, const value_type* __last)
+    : _M_t(_Compare(), allocator_type())
+    { _M_t.insert_equal(__first, __last); }
+
+  multiset(const value_type* __first, const value_type* __last,
+           const _Compare& __comp,
+           const allocator_type& __a = allocator_type())
+    : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
+
+  multiset(const_iterator __first, const_iterator __last)
+    : _M_t(_Compare(), allocator_type())
+    { _M_t.insert_equal(__first, __last); }
+
+  multiset(const_iterator __first, const_iterator __last,
+           const _Compare& __comp,
+           const allocator_type& __a = allocator_type())
+    : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
+   
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  multiset(const multiset<_Key,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {}
+  multiset<_Key,_Compare,_Alloc>&
+  operator=(const multiset<_Key,_Compare,_Alloc>& __x) {
+    _M_t = __x._M_t; 
+    return *this;
+  }
+
+  // accessors:
+
+  key_compare key_comp() const { return _M_t.key_comp(); }
+  value_compare value_comp() const { return _M_t.key_comp(); }
+  allocator_type get_allocator() const { return _M_t.get_allocator(); }
+
+  iterator begin() const { return _M_t.begin(); }
+  iterator end() const { return _M_t.end(); }
+  reverse_iterator rbegin() const { return _M_t.rbegin(); } 
+  reverse_iterator rend() const { return _M_t.rend(); }
+  bool empty() const { return _M_t.empty(); }
+  size_type size() const { return _M_t.size(); }
+  size_type max_size() const { return _M_t.max_size(); }
+  void swap(multiset<_Key,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }
+
+  // insert/erase
+  iterator insert(const value_type& __x) { 
+    return _M_t.insert_equal(__x);
+  }
+  iterator insert(iterator __position, const value_type& __x) {
+    typedef typename _Rep_type::iterator _Rep_iterator;
+    return _M_t.insert_equal((_Rep_iterator&)__position, __x);
+  }
+
+#ifdef __STL_MEMBER_TEMPLATES  
+  template <class _InputIterator>
+  void insert(_InputIterator __first, _InputIterator __last) {
+    _M_t.insert_equal(__first, __last);
+  }
+#else
+  void insert(const value_type* __first, const value_type* __last) {
+    _M_t.insert_equal(__first, __last);
+  }
+  void insert(const_iterator __first, const_iterator __last) {
+    _M_t.insert_equal(__first, __last);
+  }
+#endif /* __STL_MEMBER_TEMPLATES */
+  void erase(iterator __position) { 
+    typedef typename _Rep_type::iterator _Rep_iterator;
+    _M_t.erase((_Rep_iterator&)__position); 
+  }
+  size_type erase(const key_type& __x) { 
+    return _M_t.erase(__x); 
+  }
+  void erase(iterator __first, iterator __last) { 
+    typedef typename _Rep_type::iterator _Rep_iterator;
+    _M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last); 
+  }
+  void clear() { _M_t.clear(); }
+
+  // multiset operations:
+
+  iterator find(const key_type& __x) const { return _M_t.find(__x); }
+  size_type count(const key_type& __x) const { return _M_t.count(__x); }
+  iterator lower_bound(const key_type& __x) const {
+    return _M_t.lower_bound(__x);
+  }
+  iterator upper_bound(const key_type& __x) const {
+    return _M_t.upper_bound(__x); 
+  }
+  pair<iterator,iterator> equal_range(const key_type& __x) const {
+    return _M_t.equal_range(__x);
+  }
+  friend bool operator== __STL_NULL_TMPL_ARGS (const multiset&,
+                                               const multiset&);
+  friend bool operator< __STL_NULL_TMPL_ARGS (const multiset&,
+                                              const multiset&);
+};
+
+template <class _Key, class _Compare, class _Alloc>
+inline bool operator==(const multiset<_Key,_Compare,_Alloc>& __x, 
+                       const multiset<_Key,_Compare,_Alloc>& __y) {
+  return __x._M_t == __y._M_t;
+}
+
+template <class _Key, class _Compare, class _Alloc>
+inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x, 
+                      const multiset<_Key,_Compare,_Alloc>& __y) {
+  return __x._M_t < __y._M_t;
+}
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+
+template <class _Key, class _Compare, class _Alloc>
+inline void swap(multiset<_Key,_Compare,_Alloc>& __x, 
+                 multiset<_Key,_Compare,_Alloc>& __y) {
+  __x.swap(__y);
+}
+
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1174
+#pragma reset woff 1375
+#endif
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_MULTISET_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_numeric.h b/gnu/egcs/libstdc++/stl/stl_numeric.h
new file mode 100644
index 00000000000..da7865498ca
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_numeric.h
@@ -0,0 +1,239 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+
+#ifndef __SGI_STL_INTERNAL_NUMERIC_H
+#define __SGI_STL_INTERNAL_NUMERIC_H
+
+__STL_BEGIN_NAMESPACE
+
+template <class _InputIterator, class _Tp>
+_Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
+{
+  for ( ; __first != __last; ++__first)
+    __init = __init + *__first;
+  return __init;
+}
+
+template <class _InputIterator, class _Tp, class _BinaryOperation>
+_Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,
+               _BinaryOperation __binary_op)
+{
+  for ( ; __first != __last; ++__first)
+    __init = __binary_op(__init, *__first);
+  return __init;
+}
+
+template <class _InputIterator1, class _InputIterator2, class _Tp>
+_Tp inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
+                  _InputIterator2 __first2, _Tp __init)
+{
+  for ( ; __first1 != __last1; ++__first1, ++__first2)
+    __init = __init + (*__first1 * *__first2);
+  return __init;
+}
+
+template <class _InputIterator1, class _InputIterator2, class _Tp,
+          class _BinaryOperation1, class _BinaryOperation2>
+_Tp inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
+                  _InputIterator2 __first2, _Tp __init, 
+                  _BinaryOperation1 __binary_op1,
+                  _BinaryOperation2 __binary_op2)
+{
+  for ( ; __first1 != __last1; ++__first1, ++__first2)
+    __init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
+  return __init;
+}
+
+template <class _InputIterator, class _OutputIterator, class _Tp>
+_OutputIterator 
+__partial_sum(_InputIterator __first, _InputIterator __last,
+              _OutputIterator __result, _Tp*)
+{
+  _Tp __value = *__first;
+  while (++__first != __last) {
+    __value = __value + *__first;
+    *++__result = __value;
+  }
+  return ++__result;
+}
+
+template <class _InputIterator, class _OutputIterator>
+_OutputIterator 
+partial_sum(_InputIterator __first, _InputIterator __last,
+            _OutputIterator __result)
+{
+  if (__first == __last) return __result;
+  *__result = *__first;
+  return __partial_sum(__first, __last, __result, __VALUE_TYPE(__first));
+}
+
+template <class _InputIterator, class _OutputIterator, class _Tp,
+          class _BinaryOperation>
+_OutputIterator 
+__partial_sum(_InputIterator __first, _InputIterator __last, 
+              _OutputIterator __result, _Tp*, _BinaryOperation __binary_op)
+{
+  _Tp __value = *__first;
+  while (++__first != __last) {
+    __value = __binary_op(__value, *__first);
+    *++__result = __value;
+  }
+  return ++__result;
+}
+
+template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
+_OutputIterator 
+partial_sum(_InputIterator __first, _InputIterator __last,
+            _OutputIterator __result, _BinaryOperation __binary_op)
+{
+  if (__first == __last) return __result;
+  *__result = *__first;
+  return __partial_sum(__first, __last, __result, __VALUE_TYPE(__first), 
+                       __binary_op);
+}
+
+template <class _InputIterator, class _OutputIterator, class _Tp>
+_OutputIterator 
+__adjacent_difference(_InputIterator __first, _InputIterator __last,
+                      _OutputIterator __result, _Tp*)
+{
+  _Tp __value = *__first;
+  while (++__first != __last) {
+    _Tp __tmp = *__first;
+    *++__result = __tmp - __value;
+    __value = __tmp;
+  }
+  return ++__result;
+}
+
+template <class _InputIterator, class _OutputIterator>
+_OutputIterator
+adjacent_difference(_InputIterator __first,
+                    _InputIterator __last, _OutputIterator __result)
+{
+  if (__first == __last) return __result;
+  *__result = *__first;
+  return __adjacent_difference(__first, __last, __result,
+                               __VALUE_TYPE(__first));
+}
+
+template <class _InputIterator, class _OutputIterator, class _Tp, 
+          class _BinaryOperation>
+_OutputIterator
+__adjacent_difference(_InputIterator __first, _InputIterator __last, 
+                      _OutputIterator __result, _Tp*,
+                      _BinaryOperation __binary_op) {
+  _Tp __value = *__first;
+  while (++__first != __last) {
+    _Tp __tmp = *__first;
+    *++__result = __binary_op(__tmp, __value);
+    __value = __tmp;
+  }
+  return ++__result;
+}
+
+template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
+_OutputIterator 
+adjacent_difference(_InputIterator __first, _InputIterator __last,
+                    _OutputIterator __result, _BinaryOperation __binary_op)
+{
+  if (__first == __last) return __result;
+  *__result = *__first;
+  return __adjacent_difference(__first, __last, __result,
+                               __VALUE_TYPE(__first),
+                               __binary_op);
+}
+
+// Returns __x ** __n, where __n >= 0.  _Note that "multiplication"
+// is required to be associative, but not necessarily commutative.
+
+ 
+template <class _Tp, class _Integer, class _MonoidOperation>
+_Tp __power(_Tp __x, _Integer __n, _MonoidOperation __opr)
+{
+  if (__n == 0)
+    return identity_element(__opr);
+  else {
+    while ((__n & 1) == 0) {
+      __n >>= 1;
+      __x = __opr(__x, __x);
+    }
+
+    _Tp __result = __x;
+    __n >>= 1;
+    while (__n != 0) {
+      __x = __opr(__x, __x);
+      if ((__n & 1) != 0)
+        __result = __opr(__result, __x);
+      __n >>= 1;
+    }
+    return __result;
+  }
+}
+
+template <class _Tp, class _Integer>
+inline _Tp __power(_Tp __x, _Integer __n)
+{
+  return __power(__x, __n, multiplies<_Tp>());
+}
+
+// Alias for the internal name __power.  Note that power is an extension,
+// not part of the C++ standard.
+
+template <class _Tp, class _Integer, class _MonoidOperation>
+inline _Tp power(_Tp __x, _Integer __n, _MonoidOperation __opr)
+{
+  return __power(__x, __n, __opr);
+}
+
+template <class _Tp, class _Integer>
+inline _Tp power(_Tp __x, _Integer __n)
+{
+  return __power(__x, __n);
+}
+
+// iota is not part of the C++ standard.  It is an extension.
+
+template <class _ForwardIterator, class _Tp>
+void 
+iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
+{
+  while (__first != __last)
+    *__first++ = __value++;
+}
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_NUMERIC_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_pair.h b/gnu/egcs/libstdc++/stl/stl_pair.h
new file mode 100644
index 00000000000..3aa290b59ed
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_pair.h
@@ -0,0 +1,77 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_PAIR_H
+#define __SGI_STL_INTERNAL_PAIR_H
+
+__STL_BEGIN_NAMESPACE
+
+template <class _T1, class _T2>
+struct pair {
+  typedef _T1 first_type;
+  typedef _T2 second_type;
+
+  _T1 first;
+  _T2 second;
+  pair() : first(_T1()), second(_T2()) {}
+  pair(const _T1& __a, const _T2& __b) : first(__a), second(__b) {}
+
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _U1, class _U2>
+  pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {}
+#endif
+};
+
+template <class _T1, class _T2>
+inline bool operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+{ 
+  return __x.first == __y.first && __x.second == __y.second; 
+}
+
+template <class _T1, class _T2>
+inline bool operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+{ 
+  return __x.first < __y.first || 
+         (!(__y.first < __x.first) && __x.second < __y.second); 
+}
+
+template <class _T1, class _T2>
+inline pair<_T1, _T2> make_pair(const _T1& __x, const _T2& __y)
+{
+  return pair<_T1, _T2>(__x, __y);
+}
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_PAIR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_queue.h b/gnu/egcs/libstdc++/stl/stl_queue.h
new file mode 100644
index 00000000000..489cc4ac442
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_queue.h
@@ -0,0 +1,202 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_QUEUE_H
+#define __SGI_STL_INTERNAL_QUEUE_H
+
+__STL_BEGIN_NAMESPACE
+
+#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
+template <class _Tp, class _Sequence = deque<_Tp> >
+#else
+template <class _Tp, class _Sequence>
+#endif
+class queue {
+  friend bool operator== __STL_NULL_TMPL_ARGS (const queue&, const queue&);
+  friend bool operator< __STL_NULL_TMPL_ARGS (const queue&, const queue&);
+public:
+  typedef typename _Sequence::value_type      value_type;
+  typedef typename _Sequence::size_type       size_type;
+  typedef          _Sequence                  container_type;
+
+  typedef typename _Sequence::reference       reference;
+  typedef typename _Sequence::const_reference const_reference;
+protected:
+  _Sequence _M_c;
+public:
+  queue() : _M_c() {}
+  explicit queue(const _Sequence& __c) : _M_c(__c) {}
+
+  bool empty() const { return _M_c.empty(); }
+  size_type size() const { return _M_c.size(); }
+  reference front() { return _M_c.front(); }
+  const_reference front() const { return _M_c.front(); }
+  reference back() { return _M_c.back(); }
+  const_reference back() const { return _M_c.back(); }
+  void push(const value_type& __x) { _M_c.push_back(__x); }
+  void pop() { _M_c.pop_front(); }
+};
+
+template <class _Tp, class _Sequence>
+bool 
+operator==(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
+{
+  return __x._M_c == __y._M_c;
+}
+
+template <class _Tp, class _Sequence>
+bool
+operator<(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
+{
+  return __x._M_c < __y._M_c;
+}
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+
+template <class _Tp, class _Sequence>
+bool
+operator!=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
+{
+  return !(__x == __y);
+}
+
+template <class _Tp, class _Sequence>
+bool 
+operator>(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
+{
+  return __y < __x;
+}
+
+template <class _Tp, class _Sequence>
+bool 
+operator<=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
+{
+  return !(__y < __x);
+}
+
+template <class _Tp, class _Sequence>
+bool 
+operator>=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
+{
+  return !(__x < __y);
+}
+
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
+template <class _Tp, class _Sequence = vector<_Tp>, 
+          class _Compare = less<typename _Sequence::value_type> >
+#else
+template <class _Tp, class _Sequence, class _Compare>
+#endif
+class  priority_queue {
+public:
+  typedef typename _Sequence::value_type      value_type;
+  typedef typename _Sequence::size_type       size_type;
+  typedef          _Sequence                  container_type;
+
+  typedef typename _Sequence::reference       reference;
+  typedef typename _Sequence::const_reference const_reference;
+protected:
+  _Sequence _M_c;
+  _Compare _M_comp;
+public:
+  priority_queue() : _M_c() {}
+  explicit priority_queue(const _Compare& __x) :  _M_c(), _M_comp(__x) {}
+  priority_queue(const _Compare& __x, const _Sequence& __s) 
+    : _M_c(__s), _M_comp(__x) 
+    { make_heap(_M_c.begin(), _M_c.end(), _M_comp); }
+
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  priority_queue(_InputIterator __first, _InputIterator __last) 
+    : _M_c(__first, __last) { make_heap(_M_c.begin(), _M_c.end(), _M_comp); }
+
+  template <class _InputIterator>
+  priority_queue(_InputIterator __first, 
+                 _InputIterator __last, const _Compare& __x)
+    : _M_c(__first, __last), _M_comp(__x) 
+    { make_heap(_M_c.begin(), _M_c.end(), _M_comp); }
+
+  template <class _InputIterator>
+  priority_queue(_InputIterator __first, _InputIterator __last,
+                 const _Compare& __x, const _Sequence& __s)
+  : _M_c(__s), _M_comp(__x)
+  { 
+    _M_c.insert(_M_c.end(), __first, __last);
+    make_heap(_M_c.begin(), _M_c.end(), _M_comp);
+  }
+
+#else /* __STL_MEMBER_TEMPLATES */
+  priority_queue(const value_type* __first, const value_type* __last) 
+    : _M_c(__first, __last) { make_heap(_M_c.begin(), _M_c.end(), _M_comp); }
+
+  priority_queue(const value_type* __first, const value_type* __last, 
+                 const _Compare& __x) 
+    : _M_c(__first, __last), _M_comp(__x)
+    { make_heap(_M_c.begin(), _M_c.end(), _M_comp); }
+
+  priority_queue(const value_type* __first, const value_type* __last, 
+                 const _Compare& __x, const _Sequence& __c)
+    : _M_c(__c), _M_comp(__x) 
+  { 
+    _M_c.insert(_M_c.end(), __first, __last);
+    make_heap(_M_c.begin(), _M_c.end(), _M_comp);
+  }
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  bool empty() const { return _M_c.empty(); }
+  size_type size() const { return _M_c.size(); }
+  const_reference top() const { return _M_c.front(); }
+  void push(const value_type& __x) {
+    __STL_TRY {
+      _M_c.push_back(__x); 
+      push_heap(_M_c.begin(), _M_c.end(), _M_comp);
+    }
+    __STL_UNWIND(_M_c.clear());
+  }
+  void pop() {
+    __STL_TRY {
+      pop_heap(_M_c.begin(), _M_c.end(), _M_comp);
+      _M_c.pop_back();
+    }
+    __STL_UNWIND(_M_c.clear());
+  }
+};
+
+// no equality is provided
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_QUEUE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_raw_storage_iter.h b/gnu/egcs/libstdc++/stl/stl_raw_storage_iter.h
new file mode 100644
index 00000000000..6f3951cb8af
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_raw_storage_iter.h
@@ -0,0 +1,81 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_RAW_STORAGE_ITERATOR_H
+#define __SGI_STL_INTERNAL_RAW_STORAGE_ITERATOR_H
+
+__STL_BEGIN_NAMESPACE
+
+template <class _ForwardIterator, class _Tp>
+class raw_storage_iterator {
+protected:
+  _ForwardIterator _M_iter;
+public:
+  typedef output_iterator_tag iterator_category;
+  typedef void                value_type;
+  typedef void                difference_type;
+  typedef void                pointer;
+  typedef void                reference;
+
+  explicit raw_storage_iterator(_ForwardIterator __x) : _M_iter(__x) {}
+  raw_storage_iterator& operator*() { return *this; }
+  raw_storage_iterator& operator=(const _Tp& __element) {
+    construct(&*_M_iter, __element);
+    return *this;
+  }        
+  raw_storage_iterator<_ForwardIterator, _Tp>& operator++() {
+    ++_M_iter;
+    return *this;
+  }
+  raw_storage_iterator<_ForwardIterator, _Tp> operator++(int) {
+    raw_storage_iterator<_ForwardIterator, _Tp> __tmp = *this;
+    ++_M_iter;
+    return __tmp;
+  }
+};
+
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class _ForwardIterator, class _Tp>
+inline output_iterator_tag
+iterator_category(const raw_storage_iterator<_ForwardIterator, _Tp>&)
+{
+  return output_iterator_tag();
+}
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_RAW_STORAGE_ITERATOR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_relops.h b/gnu/egcs/libstdc++/stl/stl_relops.h
new file mode 100644
index 00000000000..16cad1b84e2
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_relops.h
@@ -0,0 +1,62 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_RELOPS
+#define __SGI_STL_INTERNAL_RELOPS
+
+__STL_BEGIN_RELOPS_NAMESPACE
+
+template <class _Tp>
+inline bool operator!=(const _Tp& __x, const _Tp& __y) {
+  return !(__x == __y);
+}
+
+template <class _Tp>
+inline bool operator>(const _Tp& __x, const _Tp& __y) {
+  return __y < __x;
+}
+
+template <class _Tp>
+inline bool operator<=(const _Tp& __x, const _Tp& __y) {
+  return !(__y < __x);
+}
+
+template <class _Tp>
+inline bool operator>=(const _Tp& __x, const _Tp& __y) {
+  return !(__x < __y);
+}
+
+__STL_END_RELOPS_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_RELOPS */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_rope.h b/gnu/egcs/libstdc++/stl/stl_rope.h
new file mode 100644
index 00000000000..44f51aed1ae
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_rope.h
@@ -0,0 +1,2541 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+// rope<_CharT,_Alloc> is a sequence of _CharT.
+// Ropes appear to be mutable, but update operations
+// really copy enough of the data structure to leave the original
+// valid.  Thus ropes can be logically copied by just copying
+// a pointer value.
+
+#ifndef __SGI_STL_INTERNAL_ROPE_H
+# define __SGI_STL_INTERNAL_ROPE_H
+
+# ifdef __GC
+#   define __GC_CONST const
+# else
+#   define __GC_CONST   // constant except for deallocation
+# endif
+# ifdef __STL_SGI_THREADS
+#    include <mutex.h>
+# endif
+
+__STL_BEGIN_NAMESPACE
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1174
+#endif
+
+// The _S_eos function is used for those functions that
+// convert to/from C-like strings to detect the end of the string.
+
+// The end-of-C-string character.
+// This is what the draft standard says it should be.
+template <class _CharT>
+inline _CharT _S_eos(_CharT*) { return _CharT(); }
+
+// Test for basic character types.
+// For basic character types leaves having a trailing eos.
+template <class _CharT>
+inline bool _S_is_basic_char_type(_CharT*) { return false; }
+template <class _CharT>
+inline bool _S_is_one_byte_char_type(_CharT*) { return false; }
+
+inline bool _S_is_basic_char_type(char*) { return true; }
+inline bool _S_is_one_byte_char_type(char*) { return true; }
+inline bool _S_is_basic_char_type(wchar_t*) { return true; }
+
+// Store an eos iff _CharT is a basic character type.
+// Do not reference _S_eos if it isn't.
+template <class _CharT>
+inline void _S_cond_store_eos(_CharT&) {}
+
+inline void _S_cond_store_eos(char& __c) { __c = 0; }
+inline void _S_cond_store_eos(wchar_t& __c) { __c = 0; }
+
+// char_producers are logically functions that generate a section of
+// a string.  These can be convereted to ropes.  The resulting rope
+// invokes the char_producer on demand.  This allows, for example,
+// files to be viewed as ropes without reading the entire file.
+template <class _CharT>
+class char_producer {
+    public:
+        virtual ~char_producer() {};
+        virtual void operator()(size_t __start_pos, size_t __len, 
+                                _CharT* __buffer) = 0;
+        // Buffer should really be an arbitrary output iterator.
+        // That way we could flatten directly into an ostream, etc.
+        // This is thoroughly impossible, since iterator types don't
+        // have runtime descriptions.
+};
+
+// Sequence buffers:
+//
+// Sequence must provide an append operation that appends an
+// array to the sequence.  Sequence buffers are useful only if
+// appending an entire array is cheaper than appending element by element.
+// This is true for many string representations.
+// This should  perhaps inherit from ostream<sequence::value_type>
+// and be implemented correspondingly, so that they can be used
+// for formatted.  For the sake of portability, we don't do this yet.
+//
+// For now, sequence buffers behave as output iterators.  But they also
+// behave a little like basic_ostringstream<sequence::value_type> and a
+// little like containers.
+
+template<class _Sequence, size_t _Buf_sz = 100
+#   if defined(__sgi) && !defined(__GNUC__)
+#        define __TYPEDEF_WORKAROUND
+         ,class _V = typename _Sequence::value_type
+#   endif
+        >
+// The 3rd parameter works around a common compiler bug.
+class sequence_buffer : public output_iterator {
+    public:
+#       ifndef __TYPEDEF_WORKAROUND
+            typedef typename _Sequence::value_type value_type;
+#       else
+            typedef _V value_type;
+#       endif
+    protected:
+        _Sequence* _M_prefix;
+        value_type _M_buffer[_Buf_sz];
+        size_t     _M_buf_count;
+    public:
+        void flush() {
+            _M_prefix->append(_M_buffer, _M_buffer + _M_buf_count);
+            _M_buf_count = 0;
+        }
+        ~sequence_buffer() { flush(); }
+        sequence_buffer() : _M_prefix(0), _M_buf_count(0) {}
+        sequence_buffer(const sequence_buffer& __x) {
+            _M_prefix = __x._M_prefix;
+            _M_buf_count = __x._M_buf_count;
+            copy(__x._M_buffer, __x._M_buffer + __x._M_buf_count, _M_buffer);
+        }
+        sequence_buffer(sequence_buffer& __x) {
+            __x.flush();
+            _M_prefix = __x._M_prefix;
+            _M_buf_count = 0;
+        }
+        sequence_buffer(_Sequence& __s) : _M_prefix(&__s), _M_buf_count(0) {}
+        sequence_buffer& operator= (sequence_buffer& __x) {
+            __x.flush();
+            _M_prefix = __x._M_prefix;
+            _M_buf_count = 0;
+            return *this;
+        }
+        sequence_buffer& operator= (const sequence_buffer& __x) {
+            _M_prefix = __x._M_prefix;
+            _M_buf_count = __x._M_buf_count;
+            copy(__x._M_buffer, __x._M_buffer + __x._M_buf_count, _M_buffer);
+            return *this;
+        }
+        void push_back(value_type __x)
+        {
+            if (_M_buf_count < _Buf_sz) {
+                _M_buffer[_M_buf_count] = __x;
+                ++_M_buf_count;
+            } else {
+                flush();
+                _M_buffer[0] = __x;
+                _M_buf_count = 1;
+            }
+        }
+        void append(value_type* __s, size_t __len)
+        {
+            if (__len + _M_buf_count <= _Buf_sz) {
+                size_t __i = _M_buf_count;
+                size_t __j = 0;
+                for (; __j < __len; __i++, __j++) {
+                    _M_buffer[__i] = __s[__j];
+                }
+                _M_buf_count += __len;
+            } else if (0 == _M_buf_count) {
+                _M_prefix->append(__s, __s + __len);
+            } else {
+                flush();
+                append(__s, __len);
+            }
+        }
+        sequence_buffer& write(value_type* __s, size_t __len)
+        {
+            append(__s, __len);
+            return *this;
+        }
+        sequence_buffer& put(value_type __x)
+        {
+            push_back(__x);
+            return *this;
+        }
+        sequence_buffer& operator=(const value_type& __rhs)
+        {
+            push_back(__rhs);
+            return *this;
+        }
+        sequence_buffer& operator*() { return *this; }
+        sequence_buffer& operator++() { return *this; }
+        sequence_buffer& operator++(int) { return *this; }
+};
+
+// The following should be treated as private, at least for now.
+template<class _CharT>
+class _Rope_char_consumer {
+    public:
+        // If we had member templates, these should not be virtual.
+        // For now we need to use run-time parametrization where
+        // compile-time would do.  _Hence this should all be private
+        // for now.
+        // The symmetry with char_producer is accidental and temporary.
+        virtual ~_Rope_char_consumer() {};
+        virtual bool operator()(const _CharT* __buffer, size_t __len) = 0;
+};
+
+//
+// What follows should really be local to rope.  Unfortunately,
+// that doesn't work, since it makes it impossible to define generic
+// equality on rope iterators.  According to the draft standard, the
+// template parameters for such an equality operator cannot be inferred
+// from the occurence of a member class as a parameter.
+// (SGI compilers in fact allow this, but the __result wouldn't be
+// portable.)
+// Similarly, some of the static member functions are member functions
+// only to avoid polluting the global namespace, and to circumvent
+// restrictions on type inference for template functions.
+//
+
+template<class _CharT, class _Alloc=__STL_DEFAULT_ALLOCATOR(_CharT)> class rope;
+template<class _CharT, class _Alloc> struct _Rope_RopeConcatenation;
+template<class _CharT, class _Alloc> struct _Rope_RopeLeaf;
+template<class _CharT, class _Alloc> struct _Rope_RopeFunction;
+template<class _CharT, class _Alloc> struct _Rope_RopeSubstring;
+template<class _CharT, class _Alloc> class _Rope_iterator;
+template<class _CharT, class _Alloc> class _Rope_const_iterator;
+template<class _CharT, class _Alloc> class _Rope_char_ref_proxy;
+template<class _CharT, class _Alloc> class _Rope_char_ptr_proxy;
+
+//
+// The internal data structure for representing a rope.  This is
+// private to the implementation.  A rope is really just a pointer
+// to one of these.
+//
+// A few basic functions for manipulating this data structure
+// are members of _RopeRep.  Most of the more complex algorithms
+// are implemented as rope members.
+//
+// Some of the static member functions of _RopeRep have identically
+// named functions in rope that simply invoke the _RopeRep versions.
+//
+// A macro to introduce various allocation and deallocation functions
+// These need to be defined differently depending on whether or not
+// we are using standard conforming allocators, and whether the allocator
+// instances have real state.  Thus this macro is invoked repeatedly
+// with different definitions of __ROPE_DEFINE_ALLOC.
+// __ROPE_DEFINE_ALLOC(type,name) defines 
+//   type * name_allocate(size_t) and
+//   void name_deallocate(tipe *, size_t)
+// Both functions may or may not be static.
+
+#define __ROPE_DEFINE_ALLOCS(__a) \
+        __ROPE_DEFINE_ALLOC(_CharT,_Data) /* character data */ \
+        typedef _Rope_RopeConcatenation<_CharT,__a> __C; \
+        __ROPE_DEFINE_ALLOC(__C,_C) \
+        typedef _Rope_RopeLeaf<_CharT,__a> __L; \
+        __ROPE_DEFINE_ALLOC(__L,_L) \
+        typedef _Rope_RopeFunction<_CharT,__a> __F; \
+        __ROPE_DEFINE_ALLOC(__F,_F) \
+        typedef _Rope_RopeSubstring<_CharT,__a> __S; \
+        __ROPE_DEFINE_ALLOC(__S,_S)
+
+//  Internal rope nodes potentially store a copy of the allocator
+//  instance used to allocate them.  This is mostly redundant.
+//  But the alternative would be to pass allocator instances around
+//  in some form to nearly all internal functions, since any pointer
+//  assignment may result in a zero reference count and thus require
+//  deallocation.
+//  The _Rope_rep_base class encapsulates
+//  the differences between SGI-style allocators and standard-conforming
+//  allocators.
+
+#ifdef __STL_USE_STD_ALLOCATORS
+
+#define __STATIC_IF_SGI_ALLOC  /* not static */
+
+// Base class for ordinary allocators.
+template <class _CharT, class _Allocator, bool _IsStatic>
+class _Rope_rep_alloc_base {
+public:
+  typedef typename _Alloc_traits<_CharT,_Allocator>::allocator_type
+          allocator_type;
+  allocator_type get_allocator() const { return _M_data_allocator; }
+  _Rope_rep_alloc_base(size_t __size, const allocator_type& __a)
+        : _M_size(__size), _M_data_allocator(__a) {}
+  size_t _M_size;       // This is here only to avoid wasting space
+                // for an otherwise empty base class.
+
+  
+protected:
+    allocator_type _M_data_allocator;
+
+# define __ROPE_DEFINE_ALLOC(_Tp, __name) \
+        typedef typename \
+          _Alloc_traits<_Tp,_Allocator>::allocator_type __name##Allocator; \
+        /*static*/ _Tp * __name##_allocate(size_t __n) \
+          { return __name##Allocator(_M_data_allocator).allocate(__n); } \
+        void __name##_deallocate(_Tp* __p, size_t __n) \
+          { __name##Allocator(_M_data_allocator).deallocate(__p, __n); }
+  __ROPE_DEFINE_ALLOCS(_Allocator);
+# undef __ROPE_DEFINE_ALLOC
+};
+
+// Specialization for allocators that have the property that we don't
+//  actually have to store an allocator object.  
+template <class _CharT, class _Allocator>
+class _Rope_rep_alloc_base<_CharT,_Allocator,true> {
+public:
+  typedef typename _Alloc_traits<_CharT,_Allocator>::allocator_type
+          allocator_type;
+  allocator_type get_allocator() const { return allocator_type(); }
+  _Rope_rep_alloc_base(size_t __size, const allocator_type&)
+                : _M_size(__size) {}
+  size_t _M_size;
+  
+protected:
+
+# define __ROPE_DEFINE_ALLOC(_Tp, __name) \
+        typedef typename \
+          _Alloc_traits<_Tp,_Allocator>::_Alloc_type __name##Alloc; \
+        typedef typename \
+          _Alloc_traits<_Tp,_Allocator>::allocator_type __name##Allocator; \
+        static _Tp* __name##_allocate(size_t __n) \
+                { return __name##Alloc::allocate(__n); } \
+        void __name##_deallocate(_Tp *__p, size_t __n) \
+                { __name##Alloc::deallocate(__p, __n); }
+  __ROPE_DEFINE_ALLOCS(_Allocator);
+# undef __ROPE_DEFINE_ALLOC
+};
+
+template <class _CharT, class _Alloc>
+struct _Rope_rep_base
+  : public _Rope_rep_alloc_base<_CharT,_Alloc,
+                                _Alloc_traits<_CharT,_Alloc>::_S_instanceless>
+{
+  typedef _Rope_rep_alloc_base<_CharT,_Alloc,
+                               _Alloc_traits<_CharT,_Alloc>::_S_instanceless>
+          _Base;
+  typedef typename _Base::allocator_type allocator_type;
+  _Rope_rep_base(size_t __size, const allocator_type& __a)
+    : _Base(__size, __a) {}
+};    
+
+#else /* !__STL_USE_STD_ALLOCATORS */
+
+#define __STATIC_IF_SGI_ALLOC static
+
+template <class _CharT, class _Alloc> 
+class _Rope_rep_base {
+public:
+  typedef _Alloc allocator_type;
+  static allocator_type get_allocator() { return allocator_type(); }
+  _Rope_rep_base(size_t __size, const allocator_type&) : _M_size(__size) {}
+  size_t _M_size;
+
+protected:
+
+# define __ROPE_DEFINE_ALLOC(_Tp, __name) \
+        typedef simple_alloc<_Tp, _Alloc> __name##Alloc; \
+        static _Tp* __name##_allocate(size_t __n) \
+                { return __name##Alloc::allocate(__n); } \
+        static void __name##_deallocate(_Tp* __p, size_t __n) \
+                { __name##Alloc::deallocate(__p, __n); }
+  __ROPE_DEFINE_ALLOCS(_Alloc);
+# undef __ROPE_DEFINE_ALLOC
+};
+
+#endif /* __STL_USE_STD_ALLOCATORS */
+
+
+template<class _CharT, class _Alloc>
+struct _Rope_RopeRep : public _Rope_rep_base<_CharT,_Alloc> {
+    public:
+    enum { _S_max_rope_depth = 45 };
+    enum _Tag {_S_leaf, _S_concat, _S_substringfn, _S_function};
+    _Tag _M_tag:8;
+    bool _M_is_balanced:8;
+    unsigned char _M_depth;
+    __GC_CONST _CharT* _M_c_string;
+                        /* Flattened version of string, if needed.  */
+                        /* typically 0.                             */
+                        /* If it's not 0, then the memory is owned  */
+                        /* by this node.                            */
+                        /* In the case of a leaf, this may point to */
+                        /* the same memory as the data field.       */
+    typedef _Rope_rep_base<_CharT,_Alloc>::allocator_type allocator_type;
+    _Rope_RopeRep(_Tag __t, int __d, bool __b, size_t __size,
+                  allocator_type __a)
+        : _M_tag(__t), _M_depth(__d), _M_is_balanced(__b), _M_c_string(0),
+          _Rope_rep_base<_CharT,_Alloc>(__size, __a)
+    {
+#       ifndef __GC
+            _M_refcount = 1;
+            _M_init_refcount_lock();
+#       endif
+    }
+#   ifndef __GC
+#       if defined(__STL_WIN32THREADS)
+            long _M_refcount;   // InterlockedIncrement wants a long *
+#       else
+            size_t _M_refcount;
+#       endif
+        // We count references from rope instances
+        // and references from other rope nodes.  We
+        // do not count const_iterator references.
+        // Iterator references are counted so that rope modifications
+        // can be detected after the fact.
+        // Generally function results are counted, i.__e.
+        // a pointer returned by a function is included at the
+        // point at which the pointer is returned.
+        // The recipient should decrement the count if the
+        // __result is not needed.
+        // Generally function arguments are not reflected
+        // in the reference count.  The callee should increment
+        // the count before saving the argument someplace that
+        // will outlive the call.
+#   endif
+#   ifndef __GC
+#       ifdef __STL_SGI_THREADS
+            // Reference counting with multiple threads and no
+            // hardware or thread package support is pretty awful.
+            // Mutexes are normally too expensive.
+            // We'll assume a COMPARE_AND_SWAP(destp, __old, new)
+            // operation, which might be cheaper.
+#           if __mips < 3 || !(defined (_ABIN32) || defined(_ABI64))
+#               define __add_and_fetch(l,v) add_then_test((unsigned long*)l,v)
+#           endif
+            void _M_init_refcount_lock() {}
+            void _M_incr_refcount ()
+            {
+                __add_and_fetch(&_M_refcount, 1);
+            }
+            size_t _M_decr_refcount ()
+            {
+                return __add_and_fetch(&_M_refcount, (size_t)(-1));
+            }
+#       elif defined(__STL_WIN32THREADS)
+            void _M_init_refcount_lock() {}
+            void _M_incr_refcount ()
+            {
+                InterlockedIncrement(&_M_refcount);
+            }
+            size_t _M_decr_refcount ()
+            {
+                return InterlockedDecrement(&_M_refcount);
+            }
+#	elif defined(__STL_PTHREADS)
+            // This should be portable, but performance is expected
+            // to be quite awful.  This really needs platform specific
+            // code.
+            pthread_mutex_t _M_refcount_lock;
+            void _M_init_refcount_lock() {
+                pthread_mutex_init(&_M_refcount_lock, 0);
+            }
+            void _M_incr_refcount ()
+            {   
+                pthread_mutex_lock(&_M_refcount_lock);
+                ++_M_refcount;
+                pthread_mutex_unlock(&_M_refcount_lock);
+            }
+            size_t _M_decr_refcount ()
+            {   
+                size_t __result;
+                pthread_mutex_lock(&_M_refcount_lock);
+                __result = --_M_refcount;
+                pthread_mutex_unlock(&_M_refcount_lock);
+                return __result;
+            }
+#       else
+            void _M_init_refcount_lock() {}
+            void _M_incr_refcount ()
+            {
+                ++_M_refcount;
+            }
+            size_t _M_decr_refcount ()
+            {
+                --_M_refcount;
+                return _M_refcount;
+            }
+#       endif
+#   else
+        void _M_incr_refcount () {}
+#   endif
+#   ifdef __STL_USE_STD_ALLOCATORS
+        static void _S_free_string(__GC_CONST _CharT*, size_t __len,
+                                   allocator_type __a);
+#       define __STL_FREE_STRING(__s, __l, __a) _S_free_string(__s, __l, __a);
+#   else
+        static void _S_free_string(__GC_CONST _CharT*, size_t __len);
+#       define __STL_FREE_STRING(__s, __l, __a) _S_free_string(__s, __l);
+#   endif
+                        // Deallocate data section of a leaf.
+                        // This shouldn't be a member function.
+                        // But its hard to do anything else at the
+                        // moment, because it's templatized w.r.t.
+                        // an allocator.
+                        // Does nothing if __GC is defined.
+#   ifndef __GC
+          void _M_free_c_string();
+          void _M_free_tree();
+                        // Deallocate t. Assumes t is not 0.
+          void _M_unref_nonnil()
+          {
+              if (0 == _M_decr_refcount()) _M_free_tree();
+          }
+          void _M_ref_nonnil()
+          {
+              _M_incr_refcount();
+          }
+          static void _S_unref(_Rope_RopeRep* __t)
+          {
+              if (0 != __t) {
+                  __t->_M_unref_nonnil();
+              }
+          }
+          static void _S_ref(_Rope_RopeRep* __t)
+          {
+              if (0 != __t) __t->_M_incr_refcount();
+          }
+          static void _S_free_if_unref(_Rope_RopeRep* __t)
+          {
+              if (0 != __t && 0 == __t->_M_refcount) __t->_M_free_tree();
+          }
+#   else /* __GC */
+          void _M_unref_nonnil() {}
+          void _M_ref_nonnil() {}
+          static void _S_unref(_Rope_RopeRep*) {}
+          static void _S_ref(_Rope_RopeRep*) {}
+          static void _S_free_if_unref(_Rope_RopeRep*) {}
+#   endif
+
+};
+
+template<class _CharT, class _Alloc>
+struct _Rope_RopeLeaf : public _Rope_RopeRep<_CharT,_Alloc> {
+  public:
+    // Apparently needed by VC++
+    // The data fields of leaves are allocated with some
+    // extra space, to accomodate future growth and for basic
+    // character types, to hold a trailing eos character.
+    enum { _S_alloc_granularity = 8 };
+    static size_t _S_rounded_up_size(size_t __n) {
+        size_t __size_with_eos;
+             
+        if (_S_is_basic_char_type((_CharT*)0)) {
+            __size_with_eos = __n + 1;
+        } else {
+            __size_with_eos = __n;
+        }
+#       ifdef __GC
+           return __size_with_eos;
+#       else
+           // Allow slop for in-place expansion.
+           return (__size_with_eos + _S_alloc_granularity-1)
+                        &~ (_S_alloc_granularity-1);
+#       endif
+    }
+    __GC_CONST _CharT* _M_data; /* Not necessarily 0 terminated. */
+                                /* The allocated size is         */
+                                /* _S_rounded_up_size(size), except */
+                                /* in the GC case, in which it   */
+                                /* doesn't matter.               */
+    typedef _Rope_rep_base<_CharT,_Alloc>::allocator_type allocator_type;
+    _Rope_RopeLeaf(__GC_CONST _CharT* __d, size_t __size, allocator_type __a)
+        : _M_data(__d)
+        , _Rope_RopeRep<_CharT,_Alloc>(_S_leaf, 0, true, __size, __a)
+        {
+        __stl_assert(__size > 0);
+        if (_S_is_basic_char_type((_CharT *)0)) {
+            // already eos terminated.
+            _M_c_string = __d;
+        }
+    }
+        // The constructor assumes that d has been allocated with
+        // the proper allocator and the properly padded size.
+        // In contrast, the destructor deallocates the data:
+# ifndef __GC
+    ~_Rope_RopeLeaf() {
+        if (_M_data != _M_c_string) {
+            _M_free_c_string();
+        }
+        __STL_FREE_STRING(_M_data, _M_size, get_allocator());
+    }
+# endif
+};
+
+template<class _CharT, class _Alloc>
+struct _Rope_RopeConcatenation : public _Rope_RopeRep<_CharT,_Alloc> {
+  public:
+    _Rope_RopeRep<_CharT,_Alloc>* _M_left;
+    _Rope_RopeRep<_CharT,_Alloc>* _M_right;
+    typedef _Rope_rep_base<_CharT,_Alloc>::allocator_type allocator_type;
+    _Rope_RopeConcatenation(_Rope_RopeRep<_CharT,_Alloc>* __l,
+                             _Rope_RopeRep<_CharT,_Alloc>* __r,
+                             allocator_type __a)
+      : _M_left(__l), _M_right(__r)
+      , _Rope_RopeRep<_CharT,_Alloc>(
+          _S_concat, max(__l->_M_depth, __r->_M_depth) + 1, false,
+          __l->_M_size + __r->_M_size, __a)
+      {}
+# ifndef __GC
+    ~_Rope_RopeConcatenation() {
+        _M_free_c_string();
+        _M_left->_M_unref_nonnil();
+        _M_right->_M_unref_nonnil();
+    }
+# endif
+};
+
+template<class _CharT, class _Alloc>
+struct _Rope_RopeFunction : public _Rope_RopeRep<_CharT,_Alloc> {
+  public:
+    char_producer<_CharT>* _M_fn;
+#   ifndef __GC
+      bool _M_delete_when_done; // Char_producer is owned by the
+                                // rope and should be explicitly
+                                // deleted when the rope becomes
+                                // inaccessible.
+#   else
+      // In the GC case, we either register the rope for
+      // finalization, or not.  Thus the field is unnecessary;
+      // the information is stored in the collector data structures.
+      // We do need a finalization procedure to be invoked by the
+      // collector.
+      static void _S_fn_finalization_proc(void * __tree, void *) {
+        delete ((_Rope_RopeFunction *)__tree) -> _M_fn;
+      }
+#   endif
+    typedef _Rope_rep_base<_CharT,_Alloc>::allocator_type allocator_type;
+    _Rope_RopeFunction(char_producer<_CharT>* __f, size_t __size,
+                        bool __d, allocator_type __a)
+      : _M_fn(__f)
+#       ifndef __GC
+      , _M_delete_when_done(__d)
+#       endif
+      , _Rope_RopeRep<_CharT,_Alloc>(_S_function, 0, true, __size, __a) {
+        __stl_assert(__size > 0);
+#       ifdef __GC
+            if (__d) {
+                GC_REGISTER_FINALIZER(
+                  this, _Rope_RopeFunction::_S_fn_finalization_proc, 0, 0, 0);
+            }
+#       endif
+    }
+# ifndef __GC
+    ~_Rope_RopeFunction() {
+          _M_free_c_string();
+          if (_M_delete_when_done) {
+              delete _M_fn;
+          }
+    }
+# endif
+};
+// Substring results are usually represented using just
+// concatenation nodes.  But in the case of very long flat ropes
+// or ropes with a functional representation that isn't practical.
+// In that case, we represent the __result as a special case of
+// RopeFunction, whose char_producer points back to the rope itself.
+// In all cases except repeated substring operations and
+// deallocation, we treat the __result as a RopeFunction.
+template<class _CharT, class _Alloc>
+struct _Rope_RopeSubstring : public _Rope_RopeFunction<_CharT,_Alloc>,
+                             public char_producer<_CharT> {
+  public:
+    // XXX this whole class should be rewritten.
+    _Rope_RopeRep<_CharT,_Alloc>* _M_base;      // not 0
+    size_t _M_start;
+    virtual void operator()(size_t __start_pos, size_t __req_len,
+                            _CharT* __buffer) {
+        switch(_M_base->_M_tag) {
+            case _S_function:
+            case _S_substringfn:
+              {
+                char_producer<_CharT>* __fn =
+                        ((_Rope_RopeFunction<_CharT,_Alloc>*)_M_base)->_M_fn;
+                __stl_assert(__start_pos + __req_len <= _M_size);
+                __stl_assert(_M_start + _M_size <= _M_base->_M_size);
+                (*__fn)(__start_pos + _M_start, __req_len, __buffer);
+              }
+              break;
+            case _S_leaf:
+              {
+                __GC_CONST _CharT* __s =
+                        ((_Rope_RopeLeaf<_CharT,_Alloc>*)_M_base)->_M_data;
+                uninitialized_copy_n(__s + __start_pos + _M_start, __req_len,
+                                     __buffer);
+              }
+              break;
+            default:
+              __stl_assert(false);
+        }
+    }
+    typedef _Rope_rep_base<_CharT,_Alloc>::allocator_type allocator_type;
+    _Rope_RopeSubstring(_Rope_RopeRep<_CharT,_Alloc>* __b, size_t __s,
+                          size_t __l, allocator_type __a)
+      : _M_base(__b)
+      , _M_start(__s)
+      , _Rope_RopeFunction<_CharT,_Alloc>(this, __l, false, __a) 
+    {
+        __stl_assert(__l > 0);
+        __stl_assert(__s + __l <= __b->_M_size);
+#       ifndef __GC
+            _M_base->_M_ref_nonnil();
+#       endif
+        _M_tag = _S_substringfn;
+    }
+    virtual ~_Rope_RopeSubstring()
+      { 
+#       ifndef __GC
+          _M_base->_M_unref_nonnil();
+          // _M_free_c_string();  -- done by parent class
+#       endif
+      }
+};
+
+
+// Self-destructing pointers to Rope_rep.
+// These are not conventional smart pointers.  Their
+// only purpose in life is to ensure that unref is called
+// on the pointer either at normal exit or if an exception
+// is raised.  It is the caller's responsibility to
+// adjust reference counts when these pointers are initialized
+// or assigned to.  (This convention significantly reduces
+// the number of potentially expensive reference count
+// updates.)
+#ifndef __GC
+  template<class _CharT, class _Alloc>
+  struct _Rope_self_destruct_ptr {
+    _Rope_RopeRep<_CharT,_Alloc>* _M_ptr;
+    ~_Rope_self_destruct_ptr() 
+      { _Rope_RopeRep<_CharT,_Alloc>::_S_unref(_M_ptr); }
+#   ifdef __STL_USE_EXCEPTIONS
+        _Rope_self_destruct_ptr() : _M_ptr(0) {};
+#   else
+        _Rope_self_destruct_ptr() {};
+#   endif
+    _Rope_self_destruct_ptr(_Rope_RopeRep<_CharT,_Alloc>* __p) : _M_ptr(__p) {}
+    _Rope_RopeRep<_CharT,_Alloc>& operator*() { return *_M_ptr; }
+    _Rope_RopeRep<_CharT,_Alloc>* operator->() { return _M_ptr; }
+    operator _Rope_RopeRep<_CharT,_Alloc>*() { return _M_ptr; }
+    _Rope_self_destruct_ptr& operator= (_Rope_RopeRep<_CharT,_Alloc>* __x)
+        { _M_ptr = __x; return *this; }
+  };
+#endif
+
+// Dereferencing a nonconst iterator has to return something
+// that behaves almost like a reference.  It's not possible to
+// return an actual reference since assignment requires extra
+// work.  And we would get into the same problems as with the
+// CD2 version of basic_string.
+template<class _CharT, class _Alloc>
+class _Rope_char_ref_proxy {
+    friend class rope<_CharT,_Alloc>;
+    friend class _Rope_iterator<_CharT,_Alloc>;
+    friend class _Rope_char_ptr_proxy<_CharT,_Alloc>;
+#   ifdef __GC
+        typedef _Rope_RopeRep<_CharT,_Alloc>* _Self_destruct_ptr;
+#   else
+        typedef _Rope_self_destruct_ptr<_CharT,_Alloc> _Self_destruct_ptr;
+#   endif
+    typedef _Rope_RopeRep<_CharT,_Alloc> _RopeRep;
+    typedef rope<_CharT,_Alloc> _My_rope;
+    size_t _M_pos;
+    _CharT _M_current;
+    bool _M_current_valid;
+    _My_rope* _M_root;     // The whole rope.
+  public:
+    _Rope_char_ref_proxy(_My_rope* __r, size_t __p) :
+        _M_pos(__p), _M_root(__r), _M_current_valid(false) {}
+    _Rope_char_ref_proxy(const _Rope_char_ref_proxy& __x) :
+        _M_pos(__x._M_pos), _M_root(__x._M_root), _M_current_valid(false) {}
+        // Don't preserve cache if the reference can outlive the
+        // expression.  We claim that's not possible without calling
+        // a copy constructor or generating reference to a proxy
+        // reference.  We declare the latter to have undefined semantics.
+    _Rope_char_ref_proxy(_My_rope* __r, size_t __p,
+                    _CharT __c) :
+        _M_pos(__p), _M_root(__r), _M_current(__c), _M_current_valid(true) {}
+    inline operator _CharT () const;
+    _Rope_char_ref_proxy& operator= (_CharT __c);
+    _Rope_char_ptr_proxy<_CharT,_Alloc> operator& () const;
+    _Rope_char_ref_proxy& operator= (const _Rope_char_ref_proxy& __c) {
+        return operator=((_CharT)__c); 
+    }
+};
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+    template<class _CharT, class __Alloc>
+    inline void swap(_Rope_char_ref_proxy <_CharT, __Alloc > __a,
+                     _Rope_char_ref_proxy <_CharT, __Alloc > __b) {
+        _CharT __tmp = __a;
+        __a = __b;
+        __b = __tmp;
+    }
+#else
+// There is no really acceptable way to handle this.  The default
+// definition of swap doesn't work for proxy references.
+// It can't really be made to work, even with ugly hacks, since
+// the only unusual operation it uses is the copy constructor, which
+// is needed for other purposes.  We provide a macro for
+// full specializations, and instantiate the most common case.
+# define _ROPE_SWAP_SPECIALIZATION(_CharT, __Alloc) \
+    inline void swap(_Rope_char_ref_proxy <_CharT, __Alloc > __a, \
+                     _Rope_char_ref_proxy <_CharT, __Alloc > __b) { \
+        _CharT __tmp = __a; \
+        __a = __b; \
+        __b = __tmp; \
+    }
+
+_ROPE_SWAP_SPECIALIZATION(char,__STL_DEFAULT_ALLOCATOR(char))
+
+#endif /* !__STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+template<class _CharT, class _Alloc>
+class _Rope_char_ptr_proxy {
+    // XXX this class should be rewritten.
+    friend class _Rope_char_ref_proxy<_CharT,_Alloc>;
+    size_t _M_pos;
+    rope<_CharT,_Alloc>* _M_root;     // The whole rope.
+  public:
+    _Rope_char_ptr_proxy(const _Rope_char_ref_proxy<_CharT,_Alloc>& __x) 
+      : _M_pos(__x._M_pos), _M_root(__x._M_root) {}
+    _Rope_char_ptr_proxy(const _Rope_char_ptr_proxy& __x)
+      : _M_pos(__x._M_pos), _M_root(__x._M_root) {}
+    _Rope_char_ptr_proxy() {}
+    _Rope_char_ptr_proxy(_CharT* __x) : _M_root(0), _M_pos(0) {
+        __stl_assert(0 == __x);
+    }
+    _Rope_char_ptr_proxy& 
+    operator= (const _Rope_char_ptr_proxy& __x) {
+        _M_pos = __x._M_pos;
+        _M_root = __x._M_root;
+        return *this;
+    }
+    friend bool operator==  __STL_NULL_TMPL_ARGS
+                (const _Rope_char_ptr_proxy<_CharT,_Alloc>& __x,
+                 const _Rope_char_ptr_proxy<_CharT,_Alloc>& __y);
+
+    _Rope_char_ref_proxy<_CharT,_Alloc> operator*() const {
+        return _Rope_char_ref_proxy<_CharT,_Alloc>(_M_root, _M_pos);
+    }
+};
+
+
+// Rope iterators:
+// Unlike in the C version, we cache only part of the stack
+// for rope iterators, since they must be efficiently copyable.
+// When we run out of cache, we have to reconstruct the iterator
+// value.
+// Pointers from iterators are not included in reference counts.
+// Iterators are assumed to be thread private.  Ropes can
+// be shared.
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1375
+#endif
+
+template<class _CharT, class _Alloc>
+class _Rope_iterator_base
+  : public random_access_iterator<_CharT, ptrdiff_t> {
+    friend class rope<_CharT,_Alloc>;
+  public:
+    typedef _Rope_RopeRep<_CharT,_Alloc> _RopeRep;
+        // Borland doesnt want this to be protected.
+  protected:
+    enum { _S_path_cache_len = 4 }; // Must be <= 9.
+    enum { _S_iterator_buf_len = 15 };
+    size_t _M_current_pos;
+    _RopeRep* _M_root;     // The whole rope.
+    size_t _M_leaf_pos;    // Starting position for current leaf
+    __GC_CONST _CharT* _M_buf_start;
+                        // Buffer possibly
+                        // containing current char.
+    __GC_CONST _CharT* _M_buf_ptr;
+                        // Pointer to current char in buffer.
+                        // != 0 ==> buffer valid.
+    __GC_CONST _CharT* _M_buf_end;
+                        // One past __last valid char in buffer.
+    // What follows is the path cache.  We go out of our
+    // way to make this compact.
+    // Path_end contains the bottom section of the path from
+    // the root to the current leaf.
+    const _RopeRep* _M_path_end[_S_path_cache_len];
+    int _M_leaf_index;     // Last valid __pos in path_end;
+                        // _M_path_end[0] ... _M_path_end[leaf_index-1]
+                        // point to concatenation nodes.
+    unsigned char _M_path_directions;
+                          // (path_directions >> __i) & 1 is 1
+                          // iff we got from _M_path_end[leaf_index - __i - 1]
+                          // to _M_path_end[leaf_index - __i] by going to the
+                          // __right. Assumes path_cache_len <= 9.
+    _CharT _M_tmp_buf[_S_iterator_buf_len];
+                        // Short buffer for surrounding chars.
+                        // This is useful primarily for 
+                        // RopeFunctions.  We put the buffer
+                        // here to avoid locking in the
+                        // multithreaded case.
+    // The cached path is generally assumed to be valid
+    // only if the buffer is valid.
+    static void _S_setbuf(_Rope_iterator_base& __x);
+                                        // Set buffer contents given
+                                        // path cache.
+    static void _S_setcache(_Rope_iterator_base& __x);
+                                        // Set buffer contents and
+                                        // path cache.
+    static void _S_setcache_for_incr(_Rope_iterator_base& __x);
+                                        // As above, but assumes path
+                                        // cache is valid for previous posn.
+    _Rope_iterator_base() {}
+    _Rope_iterator_base(_RopeRep* __root, size_t __pos)
+      : _M_root(__root), _M_current_pos(__pos), _M_buf_ptr(0) {}
+    void _M_incr(size_t __n);
+    void _M_decr(size_t __n);
+  public:
+    size_t index() const { return _M_current_pos; }
+    _Rope_iterator_base(const _Rope_iterator_base& __x) {
+        if (0 != __x._M_buf_ptr) {
+            *this = __x;
+        } else {
+            _M_current_pos = __x._M_current_pos;
+            _M_root = __x._M_root;
+            _M_buf_ptr = 0;
+        }
+    }
+};
+
+template<class _CharT, class _Alloc> class _Rope_iterator;
+
+template<class _CharT, class _Alloc>
+class _Rope_const_iterator : public _Rope_iterator_base<_CharT,_Alloc> {
+    friend class rope<_CharT,_Alloc>;
+  protected:
+    _Rope_const_iterator(const _RopeRep* __root, size_t __pos):
+                   _Rope_iterator_base<_CharT,_Alloc>(
+                     const_cast<_RopeRep*>(__root), __pos)
+                   // Only nonconst iterators modify root ref count
+    {}
+  public:
+    typedef _CharT reference;   // Really a value.  Returning a reference
+                                // Would be a mess, since it would have
+                                // to be included in refcount.
+    typedef const _CharT* pointer;
+
+  public:
+    _Rope_const_iterator() {};
+    _Rope_const_iterator(const _Rope_const_iterator& __x) :
+                                _Rope_iterator_base<_CharT,_Alloc>(__x) { }
+    _Rope_const_iterator(const _Rope_iterator<_CharT,_Alloc>& __x);
+    _Rope_const_iterator(const rope<_CharT,_Alloc>& __r, size_t __pos) :
+        _Rope_iterator_base<_CharT,_Alloc>(__r._M_tree_ptr, __pos) {}
+    _Rope_const_iterator& operator= (const _Rope_const_iterator& __x) {
+        if (0 != __x._M_buf_ptr) {
+            *(static_cast<_Rope_iterator_base<_CharT,_Alloc>*>(this)) = __x;
+        } else {
+            _M_current_pos = __x._M_current_pos;
+            _M_root = __x._M_root;
+            _M_buf_ptr = 0;
+        }
+        return(*this);
+    }
+    reference operator*() {
+        if (0 == _M_buf_ptr) _S_setcache(*this);
+        return *_M_buf_ptr;
+    }
+    _Rope_const_iterator& operator++() {
+        __GC_CONST _CharT* __next;
+        if (0 != _M_buf_ptr && (__next = _M_buf_ptr + 1) < _M_buf_end) {
+            _M_buf_ptr = __next;
+            ++_M_current_pos;
+        } else {
+            _M_incr(1);
+        }
+        return *this;
+    }
+    _Rope_const_iterator& operator+=(ptrdiff_t __n) {
+        if (__n >= 0) {
+            _M_incr(__n);
+        } else {
+            _M_decr(-__n);
+        }
+        return *this;
+    }
+    _Rope_const_iterator& operator--() {
+        _M_decr(1);
+        return *this;
+    }
+    _Rope_const_iterator& operator-=(ptrdiff_t __n) {
+        if (__n >= 0) {
+            _M_decr(__n);
+        } else {
+            _M_incr(-__n);
+        }
+        return *this;
+    }
+    _Rope_const_iterator operator++(int) {
+        size_t __old_pos = _M_current_pos;
+        _M_incr(1);
+        return _Rope_const_iterator<_CharT,_Alloc>(_M_root, __old_pos);
+        // This makes a subsequent dereference expensive.
+        // Perhaps we should instead copy the iterator
+        // if it has a valid cache?
+    }
+    _Rope_const_iterator operator--(int) {
+        size_t __old_pos = _M_current_pos;
+        _M_decr(1);
+        return _Rope_const_iterator<_CharT,_Alloc>(_M_root, __old_pos);
+    }
+    friend _Rope_const_iterator<_CharT,_Alloc> operator- __STL_NULL_TMPL_ARGS
+        (const _Rope_const_iterator<_CharT,_Alloc>& __x,
+         ptrdiff_t __n);
+    friend _Rope_const_iterator<_CharT,_Alloc> operator+ __STL_NULL_TMPL_ARGS
+        (const _Rope_const_iterator<_CharT,_Alloc>& __x,
+         ptrdiff_t __n);
+    friend _Rope_const_iterator<_CharT,_Alloc> operator+ __STL_NULL_TMPL_ARGS
+        (ptrdiff_t __n,
+         const _Rope_const_iterator<_CharT,_Alloc>& __x);
+    reference operator[](size_t __n) {
+        return rope<_CharT,_Alloc>::_S_fetch(_M_root, _M_current_pos + __n);
+    }
+    friend bool operator== __STL_NULL_TMPL_ARGS
+        (const _Rope_const_iterator<_CharT,_Alloc>& __x,
+         const _Rope_const_iterator<_CharT,_Alloc>& __y);
+    friend bool operator< __STL_NULL_TMPL_ARGS
+        (const _Rope_const_iterator<_CharT,_Alloc>& __x,
+         const _Rope_const_iterator<_CharT,_Alloc>& __y);
+    friend ptrdiff_t operator- __STL_NULL_TMPL_ARGS
+        (const _Rope_const_iterator<_CharT,_Alloc>& __x,
+         const _Rope_const_iterator<_CharT,_Alloc>& __y);
+};
+
+template<class _CharT, class _Alloc>
+class _Rope_iterator : public _Rope_iterator_base<_CharT,_Alloc> {
+    friend class rope<_CharT,_Alloc>;
+  protected:
+    rope<_CharT,_Alloc>* _M_root_rope;
+        // root is treated as a cached version of this,
+        // and is used to detect changes to the underlying
+        // rope.
+        // Root is included in the reference count.
+        // This is necessary so that we can detect changes reliably.
+        // Unfortunately, it requires careful bookkeeping for the
+        // nonGC case.
+    _Rope_iterator(rope<_CharT,_Alloc>* __r, size_t __pos)
+      : _Rope_iterator_base<_CharT,_Alloc>(__r->_M_tree_ptr, __pos),
+        _M_root_rope(__r) 
+      { _RopeRep::_S_ref(_M_root); }
+
+    void _M_check();
+  public:
+    typedef _Rope_char_ref_proxy<_CharT,_Alloc>  reference;
+    typedef _Rope_char_ref_proxy<_CharT,_Alloc>* pointer;
+
+  public:
+    rope<_CharT,_Alloc>& container() { return *_M_root_rope; }
+    _Rope_iterator() {
+        _M_root = 0;  // Needed for reference counting.
+    };
+    _Rope_iterator(const _Rope_iterator& __x) :
+        _Rope_iterator_base<_CharT,_Alloc>(__x) {
+        _M_root_rope = __x._M_root_rope;
+        _RopeRep::_S_ref(_M_root);
+    }
+    _Rope_iterator(rope<_CharT,_Alloc>& __r, size_t __pos);
+    ~_Rope_iterator() {
+        _RopeRep::_S_unref(_M_root);
+    }
+    _Rope_iterator& operator= (const _Rope_iterator& __x) {
+        _RopeRep* __old = _M_root;
+
+        _RopeRep::_S_ref(__x._M_root);
+        if (0 != __x._M_buf_ptr) {
+            _M_root_rope = __x._M_root_rope;
+            *(static_cast<_Rope_iterator_base<_CharT,_Alloc>*>(this)) = __x;
+        } else {
+            _M_current_pos = __x._M_current_pos;
+            _M_root = __x._M_root;
+            _M_root_rope = __x._M_root_rope;
+            _M_buf_ptr = 0;
+        }
+        _RopeRep::_S_unref(__old);
+        return(*this);
+    }
+    reference operator*() {
+        _M_check();
+        if (0 == _M_buf_ptr) {
+            return _Rope_char_ref_proxy<_CharT,_Alloc>(
+               _M_root_rope, _M_current_pos);
+        } else {
+            return _Rope_char_ref_proxy<_CharT,_Alloc>(
+               _M_root_rope, _M_current_pos, *_M_buf_ptr);
+        }
+    }
+    _Rope_iterator& operator++() {
+        _M_incr(1);
+        return *this;
+    }
+    _Rope_iterator& operator+=(difference_type __n) {
+        if (__n >= 0) {
+            _M_incr(__n);
+        } else {
+            _M_decr(-__n);
+        }
+        return *this;
+    }
+    _Rope_iterator& operator--() {
+        _M_decr(1);
+        return *this;
+    }
+    _Rope_iterator& operator-=(difference_type __n) {
+        if (__n >= 0) {
+            _M_decr(__n);
+        } else {
+            _M_incr(-__n);
+        }
+        return *this;
+    }
+    _Rope_iterator operator++(int) {
+        size_t __old_pos = _M_current_pos;
+        _M_incr(1);
+        return _Rope_iterator<_CharT,_Alloc>(_M_root_rope, __old_pos);
+    }
+    _Rope_iterator operator--(int) {
+        size_t __old_pos = _M_current_pos;
+        _M_decr(1);
+        return _Rope_iterator<_CharT,_Alloc>(_M_root_rope, __old_pos);
+    }
+    reference operator[](ptrdiff_t __n) {
+        return _Rope_char_ref_proxy<_CharT,_Alloc>(
+          _M_root_rope, _M_current_pos + __n);
+    }
+    friend bool operator== __STL_NULL_TMPL_ARGS
+        (const _Rope_iterator<_CharT,_Alloc>& __x,
+         const _Rope_iterator<_CharT,_Alloc>& __y);
+    friend bool operator< __STL_NULL_TMPL_ARGS
+        (const _Rope_iterator<_CharT,_Alloc>& __x,
+         const _Rope_iterator<_CharT,_Alloc>& __y);
+    friend ptrdiff_t operator- __STL_NULL_TMPL_ARGS
+        (const _Rope_iterator<_CharT,_Alloc>& __x,
+         const _Rope_iterator<_CharT,_Alloc>& __y);
+    friend _Rope_iterator<_CharT,_Alloc> operator- __STL_NULL_TMPL_ARGS
+        (const _Rope_iterator<_CharT,_Alloc>& __x,
+         ptrdiff_t __n);
+    friend _Rope_iterator<_CharT,_Alloc> operator+ __STL_NULL_TMPL_ARGS
+        (const _Rope_iterator<_CharT,_Alloc>& __x,
+         ptrdiff_t __n);
+    friend _Rope_iterator<_CharT,_Alloc> operator+ __STL_NULL_TMPL_ARGS
+        (ptrdiff_t __n,
+         const _Rope_iterator<_CharT,_Alloc>& __x);
+
+};
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1375
+#endif
+
+//  The rope base class encapsulates
+//  the differences between SGI-style allocators and standard-conforming
+//  allocators.
+
+#ifdef __STL_USE_STD_ALLOCATORS
+
+// Base class for ordinary allocators.
+template <class _CharT, class _Allocator, bool _IsStatic>
+class _Rope_alloc_base {
+public:
+  typedef _Rope_RopeRep<_CharT,_Allocator> _RopeRep;
+  typedef typename _Alloc_traits<_CharT,_Allocator>::allocator_type
+          allocator_type;
+  allocator_type get_allocator() const { return _M_data_allocator; }
+  _Rope_alloc_base(_RopeRep *__t, const allocator_type& __a)
+        : _M_tree_ptr(__t), _M_data_allocator(__a) {}
+  _Rope_alloc_base(const allocator_type& __a)
+        : _M_data_allocator(__a) {}
+  
+protected:
+  // The only data members of a rope:
+    allocator_type _M_data_allocator;
+    _RopeRep* _M_tree_ptr;
+
+# define __ROPE_DEFINE_ALLOC(_Tp, __name) \
+        typedef typename \
+          _Alloc_traits<_Tp,_Allocator>::allocator_type __name##Allocator; \
+        _Tp* __name##_allocate(size_t __n) const \
+          { return __name##Allocator(_M_data_allocator).allocate(__n); } \
+        void __name##_deallocate(_Tp *__p, size_t __n) const \
+                { __name##Allocator(_M_data_allocator).deallocate(__p, __n); }
+  __ROPE_DEFINE_ALLOCS(_Allocator)
+# undef __ROPE_DEFINE_ALLOC
+};
+
+// Specialization for allocators that have the property that we don't
+//  actually have to store an allocator object.  
+template <class _CharT, class _Allocator>
+class _Rope_alloc_base<_CharT,_Allocator,true> {
+public:
+  typedef _Rope_RopeRep<_CharT,_Allocator> _RopeRep;
+  typedef typename _Alloc_traits<_CharT,_Allocator>::allocator_type
+          allocator_type;
+  allocator_type get_allocator() const { return allocator_type(); }
+  _Rope_alloc_base(_RopeRep *__t, const allocator_type&)
+                : _M_tree_ptr(__t) {}
+  _Rope_alloc_base(const allocator_type&) {}
+  
+protected:
+  // The only data member of a rope:
+    _RopeRep *_M_tree_ptr;
+
+# define __ROPE_DEFINE_ALLOC(_Tp, __name) \
+        typedef typename \
+          _Alloc_traits<_Tp,_Allocator>::_Alloc_type __name##Alloc; \
+        typedef typename \
+          _Alloc_traits<_Tp,_Allocator>::allocator_type __name##Allocator; \
+        static _Tp* __name##_allocate(size_t __n) \
+          { return __name##Alloc::allocate(__n); } \
+        static void __name##_deallocate(_Tp *__p, size_t __n) \
+          { __name##Alloc::deallocate(__p, __n); }
+  __ROPE_DEFINE_ALLOCS(_Allocator)
+# undef __ROPE_DEFINE_ALLOC
+};
+
+template <class _CharT, class _Alloc>
+struct _Rope_base 
+  : public _Rope_alloc_base<_CharT,_Alloc,
+                            _Alloc_traits<_CharT,_Alloc>::_S_instanceless>
+{
+  typedef _Rope_alloc_base<_CharT,_Alloc,
+                            _Alloc_traits<_CharT,_Alloc>::_S_instanceless>
+          _Base;
+  typedef typename _Base::allocator_type allocator_type;
+  _Rope_base(_RopeRep* __t, const allocator_type& __a) : _Base(__t, __a) {}
+  _Rope_base(const allocator_type& __a) : _Base(__a) {}
+};    
+
+#else /* !__STL_USE_STD_ALLOCATORS */
+
+template <class _CharT, class _Alloc> 
+class _Rope_base {
+public:
+  typedef _Rope_RopeRep<_CharT, _Alloc> _RopeRep;
+  typedef _Alloc allocator_type;
+  static allocator_type get_allocator() { return allocator_type(); }
+  _Rope_base(_RopeRep * __t, const allocator_type&) : _M_tree_ptr(__t) {}
+  _Rope_base(const allocator_type&) {}
+
+protected:
+  // The only data member of a rope:
+    _RopeRep* _M_tree_ptr;
+
+# define __ROPE_DEFINE_ALLOC(_Tp, __name) \
+        typedef simple_alloc<_Tp, _Alloc> __name##Alloc; \
+        static _Tp* __name##_allocate(size_t __n) \
+                { return __name##Alloc::allocate(__n); } \
+        static void __name##_deallocate(_Tp *__p, size_t __n) \
+                { __name##Alloc::deallocate(__p, __n); }
+  __ROPE_DEFINE_ALLOCS(_Alloc)
+# undef __ROPE_DEFINE_ALLOC
+};
+
+#endif /* __STL_USE_STD_ALLOCATORS */
+
+
+template <class _CharT, class _Alloc>
+class rope : public _Rope_base<_CharT,_Alloc> {
+    public:
+        typedef _CharT value_type;
+        typedef ptrdiff_t difference_type;
+        typedef size_t size_type;
+        typedef _CharT const_reference;
+        typedef const _CharT* const_pointer;
+        typedef _Rope_iterator<_CharT,_Alloc> iterator;
+        typedef _Rope_const_iterator<_CharT,_Alloc> const_iterator;
+        typedef _Rope_char_ref_proxy<_CharT,_Alloc> reference;
+        typedef _Rope_char_ptr_proxy<_CharT,_Alloc> pointer;
+
+        friend class _Rope_iterator<_CharT,_Alloc>;
+        friend class _Rope_const_iterator<_CharT,_Alloc>;
+        friend struct _Rope_RopeRep<_CharT,_Alloc>;
+        friend class _Rope_iterator_base<_CharT,_Alloc>;
+        friend class _Rope_char_ptr_proxy<_CharT,_Alloc>;
+        friend class _Rope_char_ref_proxy<_CharT,_Alloc>;
+        friend struct _Rope_RopeSubstring<_CharT,_Alloc>;
+
+    protected:
+        typedef _Rope_base<_CharT,_Alloc> _Base;
+        typedef typename _Base::allocator_type allocator_type;
+#       ifdef __STL_USE_NAMESPACES
+          using _Base::_M_tree_ptr;
+#       endif
+        typedef __GC_CONST _CharT* _Cstrptr;
+#       ifdef __STL_SGI_THREADS
+            static _Cstrptr _S_atomic_swap(_Cstrptr* __p, _Cstrptr __q) {
+#               if __mips < 3 || !(defined (_ABIN32) || defined(_ABI64))
+                    return (_Cstrptr) test_and_set((unsigned long*)__p,
+                                                   (unsigned long)__q);
+#               else
+                    return (_Cstrptr) __test_and_set((unsigned long*)__p,
+                                                     (unsigned long)__q);
+#               endif
+            }
+#       elif defined(__STL_WIN32THREADS)
+            static _Cstrptr _S_atomic_swap(_Cstrptr* __p, _Cstrptr __q) {
+                return (_Cstrptr) InterlockedExchange(
+                  (LPLONG)__p, (LONG)__q);
+            }
+#       elif defined(__STL_PTHREADS)
+            // This should be portable, but performance is expected
+            // to be quite awful.  This really needs platform specific
+            // code.
+            static pthread_mutex_t _S_swap_lock;
+            static _Cstrptr _S_atomic_swap(_Cstrptr* __p, _Cstrptr __q) {
+                pthread_mutex_lock(&_S_swap_lock);
+                _Cstrptr __result = *__p;
+                *__p = __q;
+                pthread_mutex_unlock(&_S_swap_lock);
+                return __result;
+            }
+#       else
+            static _Cstrptr _S_atomic_swap(_Cstrptr* __p, _Cstrptr __q) {
+                _Cstrptr __result = *__p;
+                *__p = __q;
+                return __result;
+            }
+#       endif
+
+        static _CharT _S_empty_c_str[1];
+
+        static bool _S_is0(_CharT __c) { return __c == _S_eos((_CharT*)0); }
+        enum { _S_copy_max = 23 };
+                // For strings shorter than _S_copy_max, we copy to
+                // concatenate.
+
+        typedef _Rope_RopeRep<_CharT,_Alloc> _RopeRep;
+        typedef _Rope_RopeConcatenation<_CharT,_Alloc> _RopeConcatenation;
+        typedef _Rope_RopeLeaf<_CharT,_Alloc> _RopeLeaf;
+        typedef _Rope_RopeFunction<_CharT,_Alloc> _RopeFunction;
+        typedef _Rope_RopeSubstring<_CharT,_Alloc> _RopeSubstring;
+
+        // Retrieve a character at the indicated position.
+        static _CharT _S_fetch(_RopeRep* __r, size_type __pos);
+
+#       ifndef __GC
+            // Obtain a pointer to the character at the indicated position.
+            // The pointer can be used to change the character.
+            // If such a pointer cannot be produced, as is frequently the
+            // case, 0 is returned instead.
+            // (Returns nonzero only if all nodes in the path have a refcount
+            // of 1.)
+            static _CharT* _S_fetch_ptr(_RopeRep* __r, size_type __pos);
+#       endif
+
+        static bool _S_apply_to_pieces(
+                                // should be template parameter
+                                _Rope_char_consumer<_CharT>& __c,
+                                const _RopeRep* __r,
+                                size_t __begin, size_t __end);
+                                // begin and end are assumed to be in range.
+
+#       ifndef __GC
+          static void _S_unref(_RopeRep* __t)
+          {
+              _RopeRep::_S_unref(__t);
+          }
+          static void _S_ref(_RopeRep* __t)
+          {
+              _RopeRep::_S_ref(__t);
+          }
+#       else /* __GC */
+          static void _S_unref(_RopeRep*) {}
+          static void _S_ref(_RopeRep*) {}
+#       endif
+
+
+#       ifdef __GC
+            typedef _Rope_RopeRep<_CharT,_Alloc>* _Self_destruct_ptr;
+#       else
+            typedef _Rope_self_destruct_ptr<_CharT,_Alloc> _Self_destruct_ptr;
+#       endif
+
+        // _Result is counted in refcount.
+        static _RopeRep* _S_substring(_RopeRep* __base,
+                                    size_t __start, size_t __endp1);
+
+        static _RopeRep* _S_concat_char_iter(_RopeRep* __r,
+                                          const _CharT* __iter, size_t __slen);
+                // Concatenate rope and char ptr, copying __s.
+                // Should really take an arbitrary iterator.
+                // Result is counted in refcount.
+        static _RopeRep* _S_destr_concat_char_iter(_RopeRep* __r,
+                                          const _CharT* __iter, size_t __slen)
+                // As above, but one reference to __r is about to be
+                // destroyed.  Thus the pieces may be recycled if all
+                // relevent reference counts are 1.
+#           ifdef __GC
+                // We can't really do anything since refcounts are unavailable.
+                { return _S_concat_char_iter(__r, __iter, __slen); }
+#           else
+                ;
+#           endif
+
+        static _RopeRep* _S_concat(_RopeRep* __left, _RopeRep* __right);
+                // General concatenation on _RopeRep.  _Result
+                // has refcount of 1.  Adjusts argument refcounts.
+
+   public:
+        void apply_to_pieces( size_t __begin, size_t __end,
+                              _Rope_char_consumer<_CharT>& __c) const {
+            _S_apply_to_pieces(__c, _M_tree_ptr, __begin, __end);
+        }
+
+
+   protected:
+
+        static size_t _S_rounded_up_size(size_t __n) {
+            return _RopeLeaf::_S_rounded_up_size(__n);
+        }
+
+        static size_t _S_allocated_capacity(size_t __n) {
+            if (_S_is_basic_char_type((_CharT*)0)) {
+                return _S_rounded_up_size(__n) - 1;
+            } else {
+                return _S_rounded_up_size(__n);
+            }
+        }
+                
+        // Allocate and construct a RopeLeaf using the supplied allocator
+        // Takes ownership of s instead of copying.
+        static _RopeLeaf* _S_new_RopeLeaf(__GC_CONST _CharT *__s,
+                                          size_t __size, allocator_type __a)
+        {
+#           ifdef __STL_USE_STD_ALLOCATORS
+              _RopeLeaf* __space = _LAllocator(__a).allocate(1);
+#           else
+              _RopeLeaf* __space = _L_allocate(1);
+#           endif
+            return new(__space) _RopeLeaf(__s, __size, __a);
+        }
+
+        static _RopeConcatenation* _S_new_RopeConcatenation(
+                        _RopeRep* __left, _RopeRep* __right,
+                        allocator_type __a)
+        {
+#           ifdef __STL_USE_STD_ALLOCATORS
+              _RopeConcatenation* __space = _CAllocator(__a).allocate(1);
+#           else
+              _RopeConcatenation* __space = _C_allocate(1);
+#           endif
+            return new(__space) _RopeConcatenation(__left, __right, __a);
+        }
+
+        static _RopeFunction* _S_new_RopeFunction(char_producer<_CharT>* __f,
+                size_t __size, bool __d, allocator_type __a)
+        {
+#           ifdef __STL_USE_STD_ALLOCATORS
+              _RopeFunction* __space = _FAllocator(__a).allocate(1);
+#           else
+              _RopeFunction* __space = _F_allocate(1);
+#           endif
+            return new(__space) _RopeFunction(__f, __size, __d, __a);
+        }
+
+        static _RopeSubstring* _S_new_RopeSubstring(
+                _Rope_RopeRep<_CharT,_Alloc>* __b, size_t __s,
+                size_t __l, allocator_type __a)
+        {
+#           ifdef __STL_USE_STD_ALLOCATORS
+              _RopeSubstring* __space = _SAllocator(__a).allocate(1);
+#           else
+              _RopeSubstring* __space = _S_allocate(1);
+#           endif
+            return new(__space) _RopeSubstring(__b, __s, __l, __a);
+        }
+
+#       ifdef __STL_USE_STD_ALLOCATORS
+          static
+          _RopeLeaf* _S_RopeLeaf_from_unowned_char_ptr(const _CharT *__s,
+                       size_t __size, allocator_type __a)
+#         define __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __size, __a) \
+                _S_RopeLeaf_from_unowned_char_ptr(__s, __size, __a)     
+#       else
+          static
+          _RopeLeaf* _S_RopeLeaf_from_unowned_char_ptr2(const _CharT* __s,
+                                                        size_t __size)
+#         define __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __size, __a) \
+               _S_RopeLeaf_from_unowned_char_ptr2(__s, __size)
+#       endif
+        {
+            if (0 == __size) return 0;
+#           ifdef __STL_USE_STD_ALLOCATORS
+              _CharT* __buf = __a.allocate(_S_rounded_up_size(__size));
+#           else
+              _CharT* __buf = _Data_allocate(_S_rounded_up_size(__size));
+              allocator_type __a = allocator_type();
+#           endif
+
+            uninitialized_copy_n(__s, __size, __buf);
+            _S_cond_store_eos(__buf[__size]);
+            __STL_TRY {
+              return _S_new_RopeLeaf(__buf, __size, __a);
+            }
+            __STL_UNWIND(_RopeRep::__STL_FREE_STRING(__buf, __size, __a))
+        }
+            
+
+        // Concatenation of nonempty strings.
+        // Always builds a concatenation node.
+        // Rebalances if the result is too deep.
+        // Result has refcount 1.
+        // Does not increment left and right ref counts even though
+        // they are referenced.
+        static _RopeRep*
+        _S_tree_concat(_RopeRep* __left, _RopeRep* __right);
+
+        // Concatenation helper functions
+        static _RopeLeaf*
+        _S_leaf_concat_char_iter(_RopeLeaf* __r,
+                                 const _CharT* __iter, size_t __slen);
+                // Concatenate by copying leaf.
+                // should take an arbitrary iterator
+                // result has refcount 1.
+#       ifndef __GC
+          static _RopeLeaf* _S_destr_leaf_concat_char_iter
+                        (_RopeLeaf* __r, const _CharT* __iter, size_t __slen);
+          // A version that potentially clobbers __r if __r->_M_refcount == 1.
+#       endif
+
+        // A helper function for exponentiating strings.
+        // This uses a nonstandard refcount convention.
+        // The result has refcount 0.
+        struct _Concat_fn
+                : public binary_function<rope<_CharT,_Alloc>,
+                                         rope<_CharT,_Alloc>,
+                                         rope<_CharT,_Alloc> > {
+                rope operator() (const rope& __x, const rope& __y) {
+                    return __x + __y;
+                }
+        };
+
+        // Needed by the call to "power" used to build ropes
+        // consisting of n copies of a character.
+        friend rope identity_element(_Concat_fn) 
+        { return rope<_CharT,_Alloc>(); }
+
+        static size_t _S_char_ptr_len(const _CharT* __s);
+                        // slightly generalized strlen
+
+        rope(_RopeRep* __t, const allocator_type& __a = allocator_type())
+          : _Base(__t,__a) { }
+
+
+        // Copy __r to the _CharT buffer.
+        // Returns __buffer + __r->_M_size.
+        // Assumes that buffer is uninitialized.
+        static _CharT* _S_flatten(_RopeRep* __r, _CharT* __buffer);
+
+        // Again, with explicit starting position and length.
+        // Assumes that buffer is uninitialized.
+        static _CharT* _S_flatten(_RopeRep* __r,
+                                  size_t __start, size_t __len,
+                                  _CharT* __buffer);
+
+        static const unsigned long 
+          _S_min_len[_RopeRep::_S_max_rope_depth + 1];
+
+        static bool _S_is_balanced(_RopeRep* __r)
+                { return (__r->_M_size >= _S_min_len[__r->_M_depth]); }
+
+        static bool _S_is_almost_balanced(_RopeRep* __r)
+                { return (__r->_M_depth == 0 ||
+                          __r->_M_size >= _S_min_len[__r->_M_depth - 1]); }
+
+        static bool _S_is_roughly_balanced(_RopeRep* __r)
+                { return (__r->_M_depth <= 1 ||
+                          __r->_M_size >= _S_min_len[__r->_M_depth - 2]); }
+
+        // Assumes the result is not empty.
+        static _RopeRep* _S_concat_and_set_balanced(_RopeRep* __left,
+                                                     _RopeRep* __right)
+        {
+            _RopeRep* __result = _S_concat(__left, __right);
+            if (_S_is_balanced(__result)) __result->_M_is_balanced = true;
+            return __result;
+        }
+
+        // The basic rebalancing operation.  Logically copies the
+        // rope.  The result has refcount of 1.  The client will
+        // usually decrement the reference count of __r.
+        // The result is within height 2 of balanced by the above
+        // definition.
+        static _RopeRep* _S_balance(_RopeRep* __r);
+
+        // Add all unbalanced subtrees to the forest of balanceed trees.
+        // Used only by balance.
+        static void _S_add_to_forest(_RopeRep*__r, _RopeRep** __forest);
+        
+        // Add __r to forest, assuming __r is already balanced.
+        static void _S_add_leaf_to_forest(_RopeRep* __r, _RopeRep** __forest);
+
+        // Print to stdout, exposing structure
+        static void _S_dump(_RopeRep* __r, int __indent = 0);
+
+        // Return -1, 0, or 1 if __x < __y, __x == __y, or __x > __y resp.
+        static int _S_compare(const _RopeRep* __x, const _RopeRep* __y);
+
+   public:
+        bool empty() const { return 0 == _M_tree_ptr; }
+
+        // Comparison member function.  This is public only for those
+        // clients that need a ternary comparison.  Others
+        // should use the comparison operators below.
+        int compare(const rope& __y) const {
+            return _S_compare(_M_tree_ptr, __y._M_tree_ptr);
+        }
+
+        rope(const _CharT* __s, const allocator_type& __a = allocator_type())
+        : _Base(__STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, _S_char_ptr_len(__s),
+                                                 __a),__a)
+        { }
+
+        rope(const _CharT* __s, size_t __len,
+             const allocator_type& __a = allocator_type())
+        : _Base(__STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __len, __a), __a)
+        { }
+
+        // Should perhaps be templatized with respect to the iterator type
+        // and use Sequence_buffer.  (It should perhaps use sequence_buffer
+        // even now.)
+        rope(const _CharT *__s, const _CharT *__e,
+             const allocator_type& __a = allocator_type())
+        : _Base(__STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __e - __s, __a), __a)
+        { }
+
+        rope(const const_iterator& __s, const const_iterator& __e,
+             const allocator_type& __a = allocator_type())
+        : _Base(_S_substring(__s._M_root, __s._M_current_pos,
+                             __e._M_current_pos), __a)
+        { }
+
+        rope(const iterator& __s, const iterator& __e,
+             const allocator_type& __a = allocator_type())
+        : _Base(_S_substring(__s._M_root, __s._M_current_pos,
+                             __e._M_current_pos), __a)
+        { }
+
+        rope(_CharT __c, const allocator_type& __a = allocator_type())
+        : _Base(__a)
+        {
+            _CharT* __buf = _Data_allocate(_S_rounded_up_size(1));
+
+            construct(__buf, __c);
+            __STL_TRY {
+                _M_tree_ptr = _S_new_RopeLeaf(__buf, 1, __a);
+            }
+            __STL_UNWIND(_RopeRep::__STL_FREE_STRING(__buf, 1, __a))
+        }
+
+        rope(size_t __n, _CharT __c,
+             const allocator_type& __a = allocator_type());
+
+        rope(const allocator_type& __a = allocator_type())
+        : _Base(0, __a) {}
+
+        // Construct a rope from a function that can compute its members
+        rope(char_producer<_CharT> *__fn, size_t __len, bool __delete_fn,
+             const allocator_type& __a = allocator_type())
+            : _Base(__a)
+        {
+            _M_tree_ptr = (0 == __len) ?
+               0 : _S_new_RopeFunction(__fn, __len, __delete_fn, __a);
+        }
+
+        rope(const rope& __x, const allocator_type& __a = allocator_type())
+        : _Base(__x._M_tree_ptr, __a)
+        {
+            _S_ref(_M_tree_ptr);
+        }
+
+        ~rope()
+        {
+            _S_unref(_M_tree_ptr);
+        }
+
+        rope& operator=(const rope& __x)
+        {
+            _RopeRep* __old = _M_tree_ptr;
+#           ifdef __STL_USE_STD_ALLOCATORS
+              __stl_assert(get_allocator() == __x.get_allocator());
+#           endif
+            _M_tree_ptr = __x._M_tree_ptr;
+            _S_ref(_M_tree_ptr);
+            _S_unref(__old);
+            return(*this);
+        }
+
+        void push_back(_CharT __x)
+        {
+            _RopeRep* __old = _M_tree_ptr;
+            _M_tree_ptr = _S_concat_char_iter(_M_tree_ptr, &__x, 1);
+            _S_unref(__old);
+        }
+
+        void pop_back()
+        {
+            _RopeRep* __old = _M_tree_ptr;
+            _M_tree_ptr = 
+              _S_substring(_M_tree_ptr, 0, _M_tree_ptr->_M_size - 1);
+            _S_unref(__old);
+        }
+
+        _CharT back() const
+        {
+            return _S_fetch(_M_tree_ptr, _M_tree_ptr->_M_size - 1);
+        }
+
+        void push_front(_CharT __x)
+        {
+            _RopeRep* __old = _M_tree_ptr;
+            _RopeRep* __left =
+              __STL_ROPE_FROM_UNOWNED_CHAR_PTR(&__x, 1, get_allocator());
+            __STL_TRY {
+              _M_tree_ptr = _S_concat(__left, _M_tree_ptr);
+              _S_unref(__old);
+              _S_unref(__left);
+            }
+            __STL_UNWIND(_S_unref(__left))
+        }
+
+        void pop_front()
+        {
+            _RopeRep* __old = _M_tree_ptr;
+            _M_tree_ptr = _S_substring(_M_tree_ptr, 1, _M_tree_ptr->_M_size);
+            _S_unref(__old);
+        }
+
+        _CharT front() const
+        {
+            return _S_fetch(_M_tree_ptr, 0);
+        }
+
+        void balance()
+        {
+            _RopeRep* __old = _M_tree_ptr;
+            _M_tree_ptr = _S_balance(_M_tree_ptr);
+            _S_unref(__old);
+        }
+
+        void copy(_CharT* __buffer) const {
+            destroy(__buffer, __buffer + size());
+            _S_flatten(_M_tree_ptr, __buffer);
+        }
+
+        // This is the copy function from the standard, but
+        // with the arguments reordered to make it consistent with the
+        // rest of the interface.
+        // Note that this guaranteed not to compile if the draft standard
+        // order is assumed.
+        size_type copy(size_type __pos, size_type __n, _CharT* __buffer) const 
+        {
+            size_t __size = size();
+            size_t __len = (__pos + __n > __size? __size - __pos : __n);
+
+            destroy(__buffer, __buffer + __len);
+            _S_flatten(_M_tree_ptr, __pos, __len, __buffer);
+            return __len;
+        }
+
+        // Print to stdout, exposing structure.  May be useful for
+        // performance debugging.
+        void dump() {
+            _S_dump(_M_tree_ptr);
+        }
+
+        // Convert to 0 terminated string in new allocated memory.
+        // Embedded 0s in the input do not terminate the copy.
+        const _CharT* c_str() const;
+
+        // As above, but lso use the flattened representation as the
+        // the new rope representation.
+        const _CharT* replace_with_c_str();
+
+        // Reclaim memory for the c_str generated flattened string.
+        // Intentionally undocumented, since it's hard to say when this
+        // is safe for multiple threads.
+        void delete_c_str () {
+            if (0 == _M_tree_ptr) return;
+            if (_RopeRep::_S_leaf == _M_tree_ptr->_M_tag && 
+                ((_RopeLeaf*)_M_tree_ptr)->_M_data == 
+                      _M_tree_ptr->_M_c_string) {
+                // Representation shared
+                return;
+            }
+#           ifndef __GC
+              _M_tree_ptr->_M_free_c_string();
+#           endif
+            _M_tree_ptr->_M_c_string = 0;
+        }
+
+        _CharT operator[] (size_type __pos) const {
+            return _S_fetch(_M_tree_ptr, __pos);
+        }
+
+        _CharT at(size_type __pos) const {
+           // if (__pos >= size()) throw out_of_range;  // XXX
+           return (*this)[__pos];
+        }
+
+        const_iterator begin() const {
+            return(const_iterator(_M_tree_ptr, 0));
+        }
+
+        // An easy way to get a const iterator from a non-const container.
+        const_iterator const_begin() const {
+            return(const_iterator(_M_tree_ptr, 0));
+        }
+
+        const_iterator end() const {
+            return(const_iterator(_M_tree_ptr, size()));
+        }
+
+        const_iterator const_end() const {
+            return(const_iterator(_M_tree_ptr, size()));
+        }
+
+        size_type size() const { 
+            return(0 == _M_tree_ptr? 0 : _M_tree_ptr->_M_size);
+        }
+
+        size_type length() const {
+            return size();
+        }
+
+        size_type max_size() const {
+            return _S_min_len[_RopeRep::_S_max_rope_depth-1] - 1;
+            //  Guarantees that the result can be sufficirntly
+            //  balanced.  Longer ropes will probably still work,
+            //  but it's harder to make guarantees.
+        }
+
+#     ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+        typedef reverse_iterator<const_iterator> const_reverse_iterator;
+#     else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+        typedef reverse_iterator<const_iterator, value_type, const_reference,
+                                 difference_type>  const_reverse_iterator;
+#     endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ 
+
+        const_reverse_iterator rbegin() const {
+            return const_reverse_iterator(end());
+        }
+
+        const_reverse_iterator const_rbegin() const {
+            return const_reverse_iterator(end());
+        }
+
+        const_reverse_iterator rend() const {
+            return const_reverse_iterator(begin());
+        }
+
+        const_reverse_iterator const_rend() const {
+            return const_reverse_iterator(begin());
+        }
+
+        friend rope<_CharT,_Alloc>
+        operator+ __STL_NULL_TMPL_ARGS (const rope<_CharT,_Alloc>& __left,
+                                        const rope<_CharT,_Alloc>& __right);
+        
+        friend rope<_CharT,_Alloc>
+        operator+ __STL_NULL_TMPL_ARGS (const rope<_CharT,_Alloc>& __left,
+                                        const _CharT* __right);
+        
+        friend rope<_CharT,_Alloc>
+        operator+ __STL_NULL_TMPL_ARGS (const rope<_CharT,_Alloc>& __left,
+                                        _CharT __right);
+        
+        // The symmetric cases are intentionally omitted, since they're presumed
+        // to be less common, and we don't handle them as well.
+
+        // The following should really be templatized.
+        // The first argument should be an input iterator or
+        // forward iterator with value_type _CharT.
+        rope& append(const _CharT* __iter, size_t __n) {
+            _RopeRep* __result = 
+              _S_destr_concat_char_iter(_M_tree_ptr, __iter, __n);
+            _S_unref(_M_tree_ptr);
+            _M_tree_ptr = __result;
+            return *this;
+        }
+
+        rope& append(const _CharT* __c_string) {
+            size_t __len = _S_char_ptr_len(__c_string);
+            append(__c_string, __len);
+            return(*this);
+        }
+
+        rope& append(const _CharT* __s, const _CharT* __e) {
+            _RopeRep* __result =
+                _S_destr_concat_char_iter(_M_tree_ptr, __s, __e - __s);
+            _S_unref(_M_tree_ptr);
+            _M_tree_ptr = __result;
+            return *this;
+        }
+
+        rope& append(const_iterator __s, const_iterator __e) {
+            __stl_assert(__s._M_root == __e._M_root);
+#           ifdef __STL_USE_STD_ALLOCATORS
+                __stl_assert(get_allocator() == __s._M_root->get_allocator());
+#           endif
+            _Self_destruct_ptr __appendee(_S_substring(
+              __s._M_root, __s._M_current_pos, __e._M_current_pos));
+            _RopeRep* __result = 
+              _S_concat(_M_tree_ptr, (_RopeRep*)__appendee);
+            _S_unref(_M_tree_ptr);
+            _M_tree_ptr = __result;
+            return *this;
+        }
+
+        rope& append(_CharT __c) {
+            _RopeRep* __result = 
+              _S_destr_concat_char_iter(_M_tree_ptr, &__c, 1);
+            _S_unref(_M_tree_ptr);
+            _M_tree_ptr = __result;
+            return *this;
+        }
+
+        rope& append() { return append(_CharT()); }  // XXX why?
+
+        rope& append(const rope& __y) {
+#           ifdef __STL_USE_STD_ALLOCATORS
+              __stl_assert(__y.get_allocator() == get_allocator());
+#           endif
+            _RopeRep* __result = _S_concat(_M_tree_ptr, __y._M_tree_ptr);
+            _S_unref(_M_tree_ptr);
+            _M_tree_ptr = __result;
+            return *this;
+        }
+
+        rope& append(size_t __n, _CharT __c) {
+            rope<_CharT,_Alloc> __last(__n, __c);
+            return append(__last);
+        }
+
+        void swap(rope& __b) {
+#           ifdef __STL_USE_STD_ALLOCATORS
+                __stl_assert(get_allocator() == __b.get_allocator());
+#           endif
+            _RopeRep* __tmp = _M_tree_ptr;
+            _M_tree_ptr = __b._M_tree_ptr;
+            __b._M_tree_ptr = __tmp;
+        }
+
+
+    protected:
+        // Result is included in refcount.
+        static _RopeRep* replace(_RopeRep* __old, size_t __pos1,
+                                  size_t __pos2, _RopeRep* __r) {
+            if (0 == __old) { _S_ref(__r); return __r; }
+            _Self_destruct_ptr __left(
+              _S_substring(__old, 0, __pos1));
+            _Self_destruct_ptr __right(
+              _S_substring(__old, __pos2, __old->_M_size));
+            _RopeRep* __result;
+
+#           ifdef __STL_USE_STD_ALLOCATORS
+                __stl_assert(__old->get_allocator() == __r->get_allocator());
+#           endif
+            if (0 == __r) {
+                __result = _S_concat(__left, __right);
+            } else {
+                _Self_destruct_ptr __left_result(_S_concat(__left, __r));
+                __result = _S_concat(__left_result, __right);
+            }
+            return __result;
+        }
+
+    public:
+        void insert(size_t __p, const rope& __r) {
+            _RopeRep* __result = 
+              replace(_M_tree_ptr, __p, __p, __r._M_tree_ptr);
+#           ifdef __STL_USE_STD_ALLOCATORS
+                __stl_assert(get_allocator() == __r.get_allocator());
+#           endif
+            _S_unref(_M_tree_ptr);
+            _M_tree_ptr = __result;
+        }
+
+        void insert(size_t __p, size_t __n, _CharT __c) {
+            rope<_CharT,_Alloc> __r(__n,__c);
+            insert(__p, __r);
+        }
+
+        void insert(size_t __p, const _CharT* __i, size_t __n) {
+            _Self_destruct_ptr __left(_S_substring(_M_tree_ptr, 0, __p));
+            _Self_destruct_ptr __right(_S_substring(_M_tree_ptr, __p, size()));
+            _Self_destruct_ptr __left_result(
+              _S_concat_char_iter(__left, __i, __n));
+            _RopeRep* __result = _S_concat(__left_result, __right);
+            _S_unref(_M_tree_ptr);
+            _M_tree_ptr = __result;
+        }
+
+        void insert(size_t __p, const _CharT* __c_string) {
+            insert(__p, __c_string, _S_char_ptr_len(__c_string));
+        }
+
+        void insert(size_t __p, _CharT __c) {
+            insert(__p, &__c, 1);
+        }
+
+        void insert(size_t __p) {
+            _CharT __c = _CharT();
+            insert(__p, &__c, 1);
+        }
+
+        void insert(size_t __p, const _CharT* __i, const _CharT* __j) {
+            rope __r(__i, __j);
+            insert(__p, __r);
+        }
+
+        void insert(size_t __p, const const_iterator& __i,
+                              const const_iterator& __j) {
+            rope __r(__i, __j);
+            insert(__p, __r);
+        }
+
+        void insert(size_t __p, const iterator& __i,
+                              const iterator& __j) {
+            rope __r(__i, __j);
+            insert(__p, __r);
+        }
+
+        // (position, length) versions of replace operations:
+
+        void replace(size_t __p, size_t __n, const rope& __r) {
+            _RopeRep* __result = 
+              replace(_M_tree_ptr, __p, __p + __n, __r._M_tree_ptr);
+            _S_unref(_M_tree_ptr);
+            _M_tree_ptr = __result;
+        }
+
+        void replace(size_t __p, size_t __n, 
+                     const _CharT* __i, size_t __i_len) {
+            rope __r(__i, __i_len);
+            replace(__p, __n, __r);
+        }
+
+        void replace(size_t __p, size_t __n, _CharT __c) {
+            rope __r(__c);
+            replace(__p, __n, __r);
+        }
+
+        void replace(size_t __p, size_t __n, const _CharT* __c_string) {
+            rope __r(__c_string);
+            replace(__p, __n, __r);
+        }
+
+        void replace(size_t __p, size_t __n, 
+                     const _CharT* __i, const _CharT* __j) {
+            rope __r(__i, __j);
+            replace(__p, __n, __r);
+        }
+
+        void replace(size_t __p, size_t __n,
+                     const const_iterator& __i, const const_iterator& __j) {
+            rope __r(__i, __j);
+            replace(__p, __n, __r);
+        }
+
+        void replace(size_t __p, size_t __n,
+                     const iterator& __i, const iterator& __j) {
+            rope __r(__i, __j);
+            replace(__p, __n, __r);
+        }
+
+        // Single character variants:
+        void replace(size_t __p, _CharT __c) {
+            iterator __i(this, __p);
+            *__i = __c;
+        }
+
+        void replace(size_t __p, const rope& __r) {
+            replace(__p, 1, __r);
+        }
+
+        void replace(size_t __p, const _CharT* __i, size_t __i_len) {
+            replace(__p, 1, __i, __i_len);
+        }
+
+        void replace(size_t __p, const _CharT* __c_string) {
+            replace(__p, 1, __c_string);
+        }
+
+        void replace(size_t __p, const _CharT* __i, const _CharT* __j) {
+            replace(__p, 1, __i, __j);
+        }
+
+        void replace(size_t __p, const const_iterator& __i,
+                               const const_iterator& __j) {
+            replace(__p, 1, __i, __j);
+        }
+
+        void replace(size_t __p, const iterator& __i,
+                               const iterator& __j) {
+            replace(__p, 1, __i, __j);
+        }
+
+        // Erase, (position, size) variant.
+        void erase(size_t __p, size_t __n) {
+            _RopeRep* __result = replace(_M_tree_ptr, __p, __p + __n, 0);
+            _S_unref(_M_tree_ptr);
+            _M_tree_ptr = __result;
+        }
+
+        // Erase, single character
+        void erase(size_t __p) {
+            erase(__p, __p + 1);
+        }
+
+        // Insert, iterator variants.  
+        iterator insert(const iterator& __p, const rope& __r)
+                { insert(__p.index(), __r); return __p; }
+        iterator insert(const iterator& __p, size_t __n, _CharT __c)
+                { insert(__p.index(), __n, __c); return __p; }
+        iterator insert(const iterator& __p, _CharT __c) 
+                { insert(__p.index(), __c); return __p; }
+        iterator insert(const iterator& __p ) 
+                { insert(__p.index()); return __p; }
+        iterator insert(const iterator& __p, const _CharT* c_string) 
+                { insert(__p.index(), c_string); return __p; }
+        iterator insert(const iterator& __p, const _CharT* __i, size_t __n)
+                { insert(__p.index(), __i, __n); return __p; }
+        iterator insert(const iterator& __p, const _CharT* __i, 
+                        const _CharT* __j)
+                { insert(__p.index(), __i, __j);  return __p; }
+        iterator insert(const iterator& __p,
+                        const const_iterator& __i, const const_iterator& __j)
+                { insert(__p.index(), __i, __j); return __p; }
+        iterator insert(const iterator& __p,
+                        const iterator& __i, const iterator& __j)
+                { insert(__p.index(), __i, __j); return __p; }
+
+        // Replace, range variants.
+        void replace(const iterator& __p, const iterator& __q,
+                     const rope& __r)
+                { replace(__p.index(), __q.index() - __p.index(), __r); }
+        void replace(const iterator& __p, const iterator& __q, _CharT __c)
+                { replace(__p.index(), __q.index() - __p.index(), __c); }
+        void replace(const iterator& __p, const iterator& __q,
+                     const _CharT* __c_string)
+                { replace(__p.index(), __q.index() - __p.index(), __c_string); }
+        void replace(const iterator& __p, const iterator& __q,
+                     const _CharT* __i, size_t __n)
+                { replace(__p.index(), __q.index() - __p.index(), __i, __n); }
+        void replace(const iterator& __p, const iterator& __q,
+                     const _CharT* __i, const _CharT* __j)
+                { replace(__p.index(), __q.index() - __p.index(), __i, __j); }
+        void replace(const iterator& __p, const iterator& __q,
+                     const const_iterator& __i, const const_iterator& __j)
+                { replace(__p.index(), __q.index() - __p.index(), __i, __j); }
+        void replace(const iterator& __p, const iterator& __q,
+                     const iterator& __i, const iterator& __j)
+                { replace(__p.index(), __q.index() - __p.index(), __i, __j); }
+
+        // Replace, iterator variants.
+        void replace(const iterator& __p, const rope& __r)
+                { replace(__p.index(), __r); }
+        void replace(const iterator& __p, _CharT __c)
+                { replace(__p.index(), __c); }
+        void replace(const iterator& __p, const _CharT* __c_string)
+                { replace(__p.index(), __c_string); }
+        void replace(const iterator& __p, const _CharT* __i, size_t __n)
+                { replace(__p.index(), __i, __n); }
+        void replace(const iterator& __p, const _CharT* __i, const _CharT* __j)
+                { replace(__p.index(), __i, __j); }
+        void replace(const iterator& __p, const_iterator __i, 
+                     const_iterator __j)
+                { replace(__p.index(), __i, __j); }
+        void replace(const iterator& __p, iterator __i, iterator __j)
+                { replace(__p.index(), __i, __j); }
+
+        // Iterator and range variants of erase
+        iterator erase(const iterator& __p, const iterator& __q) {
+            size_t __p_index = __p.index();
+            erase(__p_index, __q.index() - __p_index);
+            return iterator(this, __p_index);
+        }
+        iterator erase(const iterator& __p) {
+            size_t __p_index = __p.index();
+            erase(__p_index, 1);
+            return iterator(this, __p_index);
+        }
+
+        rope substr(size_t __start, size_t __len = 1) const {
+            return rope<_CharT,_Alloc>(
+                        _S_substring(_M_tree_ptr, __start, __start + __len));
+        }
+
+        rope substr(iterator __start, iterator __end) const {
+            return rope<_CharT,_Alloc>(
+                _S_substring(_M_tree_ptr, __start.index(), __end.index()));
+        }
+        
+        rope substr(iterator __start) const {
+            size_t __pos = __start.index();
+            return rope<_CharT,_Alloc>(
+                        _S_substring(_M_tree_ptr, __pos, __pos + 1));
+        }
+        
+        rope substr(const_iterator __start, const_iterator __end) const {
+            // This might eventually take advantage of the cache in the
+            // iterator.
+            return rope<_CharT,_Alloc>(
+              _S_substring(_M_tree_ptr, __start.index(), __end.index()));
+        }
+
+        rope<_CharT,_Alloc> substr(const_iterator __start) {
+            size_t __pos = __start.index();
+            return rope<_CharT,_Alloc>(
+              _S_substring(_M_tree_ptr, __pos, __pos + 1));
+        }
+
+        static const size_type npos;
+
+        size_type find(_CharT __c, size_type __pos = 0) const;
+        size_type find(_CharT* __s, size_type __pos = 0) const {
+            size_type __result_pos;
+            const_iterator __result = search(const_begin() + __pos, const_end(),
+                                           __s, __s + _S_char_ptr_len(__s));
+            __result_pos = __result.index();
+#           ifndef __STL_OLD_ROPE_SEMANTICS
+                if (__result_pos == size()) __result_pos = npos;
+#           endif
+            return __result_pos;
+        }
+
+        iterator mutable_begin() {
+            return(iterator(this, 0));
+        }
+
+        iterator mutable_end() {
+            return(iterator(this, size()));
+        }
+
+#     ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+        typedef reverse_iterator<iterator> reverse_iterator;
+#     else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+        typedef reverse_iterator<iterator, value_type, reference,
+                                 difference_type>  reverse_iterator;
+#     endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ 
+
+        reverse_iterator mutable_rbegin() {
+            return reverse_iterator(mutable_end());
+        }
+
+        reverse_iterator mutable_rend() {
+            return reverse_iterator(mutable_begin());
+        }
+
+        reference mutable_reference_at(size_type __pos) {
+            return reference(this, __pos);
+        }
+
+#       ifdef __STD_STUFF
+            reference operator[] (size_type __pos) {
+                return _char_ref_proxy(this, __pos);
+            }
+
+            reference at(size_type __pos) {
+                // if (__pos >= size()) throw out_of_range;  // XXX
+                return (*this)[__pos];
+            }
+
+            void resize(size_type __n, _CharT __c) {}
+            void resize(size_type __n) {}
+            void reserve(size_type __res_arg = 0) {}
+            size_type capacity() const {
+                return max_size();
+            }
+
+          // Stuff below this line is dangerous because it's error prone.
+          // I would really like to get rid of it.
+            // copy function with funny arg ordering.
+              size_type copy(_CharT* __buffer, size_type __n, 
+                             size_type __pos = 0) const {
+                return copy(__pos, __n, __buffer);
+              }
+
+            iterator end() { return mutable_end(); }
+
+            iterator begin() { return mutable_begin(); }
+
+            reverse_iterator rend() { return mutable_rend(); }
+
+            reverse_iterator rbegin() { return mutable_rbegin(); }
+
+#       else
+
+            const_iterator end() { return const_end(); }
+
+            const_iterator begin() { return const_begin(); }
+
+            const_reverse_iterator rend() { return const_rend(); }
+  
+            const_reverse_iterator rbegin() { return const_rbegin(); }
+
+#       endif
+        
+};
+
+template <class _CharT, class _Alloc>
+const rope<_CharT, _Alloc>::size_type rope<_CharT, _Alloc>::npos =
+			(size_type)(-1);
+
+template <class _CharT, class _Alloc>
+inline bool operator== (const _Rope_const_iterator<_CharT,_Alloc>& __x,
+                        const _Rope_const_iterator<_CharT,_Alloc>& __y) {
+  return (__x._M_current_pos == __y._M_current_pos && 
+          __x._M_root == __y._M_root);
+}
+
+template <class _CharT, class _Alloc>
+inline bool operator< (const _Rope_const_iterator<_CharT,_Alloc>& __x,
+                       const _Rope_const_iterator<_CharT,_Alloc>& __y) {
+  return (__x._M_current_pos < __y._M_current_pos);
+}
+
+template <class _CharT, class _Alloc>
+inline ptrdiff_t operator-(const _Rope_const_iterator<_CharT,_Alloc>& __x,
+                           const _Rope_const_iterator<_CharT,_Alloc>& __y) {
+  return (ptrdiff_t)__x._M_current_pos - (ptrdiff_t)__y._M_current_pos;
+}
+
+template <class _CharT, class _Alloc>
+inline _Rope_const_iterator<_CharT,_Alloc>
+operator-(const _Rope_const_iterator<_CharT,_Alloc>& __x, ptrdiff_t __n) {
+  return _Rope_const_iterator<_CharT,_Alloc>(
+            __x._M_root, __x._M_current_pos - __n);
+}
+
+template <class _CharT, class _Alloc>
+inline _Rope_const_iterator<_CharT,_Alloc>
+operator+(const _Rope_const_iterator<_CharT,_Alloc>& __x, ptrdiff_t __n) {
+  return _Rope_const_iterator<_CharT,_Alloc>(
+           __x._M_root, __x._M_current_pos + __n);
+}
+
+template <class _CharT, class _Alloc>
+inline _Rope_const_iterator<_CharT,_Alloc>
+operator+(ptrdiff_t __n, const _Rope_const_iterator<_CharT,_Alloc>& __x) {
+  return _Rope_const_iterator<_CharT,_Alloc>(
+           __x._M_root, __x._M_current_pos + __n);
+}
+
+template <class _CharT, class _Alloc>
+inline bool operator== (const _Rope_iterator<_CharT,_Alloc>& __x,
+                        const _Rope_iterator<_CharT,_Alloc>& __y) {
+  return (__x._M_current_pos == __y._M_current_pos && 
+          __x._M_root_rope == __y._M_root_rope);
+}
+
+template <class _CharT, class _Alloc>
+inline bool operator< (const _Rope_iterator<_CharT,_Alloc>& __x,
+                       const _Rope_iterator<_CharT,_Alloc>& __y) {
+  return (__x._M_current_pos < __y._M_current_pos);
+}
+
+template <class _CharT, class _Alloc>
+inline ptrdiff_t operator-(const _Rope_iterator<_CharT,_Alloc>& __x,
+                           const _Rope_iterator<_CharT,_Alloc>& __y) {
+  return (ptrdiff_t)__x._M_current_pos - (ptrdiff_t)__y._M_current_pos;
+}
+
+template <class _CharT, class _Alloc>
+inline _Rope_iterator<_CharT,_Alloc>
+operator-(const _Rope_iterator<_CharT,_Alloc>& __x,
+          ptrdiff_t __n) {
+  return _Rope_iterator<_CharT,_Alloc>(
+    __x._M_root_rope, __x._M_current_pos - __n);
+}
+
+template <class _CharT, class _Alloc>
+inline _Rope_iterator<_CharT,_Alloc>
+operator+(const _Rope_iterator<_CharT,_Alloc>& __x,
+          ptrdiff_t __n) {
+  return _Rope_iterator<_CharT,_Alloc>(
+    __x._M_root_rope, __x._M_current_pos + __n);
+}
+
+template <class _CharT, class _Alloc>
+inline _Rope_iterator<_CharT,_Alloc>
+operator+(ptrdiff_t __n, const _Rope_iterator<_CharT,_Alloc>& __x) {
+  return _Rope_iterator<_CharT,_Alloc>(
+    __x._M_root_rope, __x._M_current_pos + __n);
+}
+
+template <class _CharT, class _Alloc>
+inline
+rope<_CharT,_Alloc>
+operator+ (const rope<_CharT,_Alloc>& __left,
+           const rope<_CharT,_Alloc>& __right)
+{
+#   ifdef __STL_USE_STD_ALLOCATORS
+        __stl_assert(__left.get_allocator() == __right.get_allocator());
+#   endif
+    return rope<_CharT,_Alloc>(
+      rope<_CharT,_Alloc>::_S_concat(__left._M_tree_ptr, __right._M_tree_ptr));
+    // Inlining this should make it possible to keep __left and
+    // __right in registers.
+}
+
+template <class _CharT, class _Alloc>
+inline
+rope<_CharT,_Alloc>&
+operator+= (rope<_CharT,_Alloc>& __left, 
+      const rope<_CharT,_Alloc>& __right)
+{
+    __left.append(__right);
+    return __left;
+}
+
+template <class _CharT, class _Alloc>
+inline
+rope<_CharT,_Alloc>
+operator+ (const rope<_CharT,_Alloc>& __left,
+           const _CharT* __right) {
+    size_t __rlen = rope<_CharT,_Alloc>::_S_char_ptr_len(__right);
+    return rope<_CharT,_Alloc>(
+      rope<_CharT,_Alloc>::_S_concat_char_iter(
+        __left._M_tree_ptr, __right, __rlen)); 
+}
+
+template <class _CharT, class _Alloc>
+inline
+rope<_CharT,_Alloc>&
+operator+= (rope<_CharT,_Alloc>& __left,
+            const _CharT* __right) {
+    __left.append(__right);
+    return __left;
+}
+
+template <class _CharT, class _Alloc>
+inline
+rope<_CharT,_Alloc>
+operator+ (const rope<_CharT,_Alloc>& __left, _CharT __right) {
+    return rope<_CharT,_Alloc>(
+      rope<_CharT,_Alloc>::_S_concat_char_iter(
+        __left._M_tree_ptr, &__right, 1));
+}
+
+template <class _CharT, class _Alloc>
+inline
+rope<_CharT,_Alloc>&
+operator+= (rope<_CharT,_Alloc>& __left, _CharT __right) {
+    __left.append(__right);
+    return __left;
+}
+
+template <class _CharT, class _Alloc>
+bool
+operator< (const rope<_CharT,_Alloc>& __left, 
+           const rope<_CharT,_Alloc>& __right) {
+    return __left.compare(__right) < 0;
+}
+        
+template <class _CharT, class _Alloc>
+bool
+operator== (const rope<_CharT,_Alloc>& __left, 
+            const rope<_CharT,_Alloc>& __right) {
+    return __left.compare(__right) == 0;
+}
+
+template <class _CharT, class _Alloc>
+inline bool operator== (const _Rope_char_ptr_proxy<_CharT,_Alloc>& __x,
+                        const _Rope_char_ptr_proxy<_CharT,_Alloc>& __y) {
+        return (__x._M_pos == __y._M_pos && __x._M_root == __y._M_root);
+}
+
+template<class _CharT, class _Alloc>
+ostream& operator<< (ostream& __o, const rope<_CharT,_Alloc>& __r);        
+        
+typedef rope<char> crope;
+typedef rope<wchar_t> wrope;
+
+inline crope::reference __mutable_reference_at(crope& __c, size_t __i)
+{
+    return __c.mutable_reference_at(__i);
+}
+
+inline wrope::reference __mutable_reference_at(wrope& __c, size_t __i)
+{
+    return __c.mutable_reference_at(__i);
+}
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+
+template <class _CharT, class _Alloc>
+inline void swap(rope<_CharT,_Alloc>& __x, rope<_CharT,_Alloc>& __y) {
+  __x.swap(__y);
+}
+
+#else
+
+inline void swap(crope __x, crope __y) { __x.swap(__y); }
+inline void swap(wrope __x, wrope __y) { __x.swap(__y); }
+
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+// Hash functions should probably be revisited later:
+__STL_TEMPLATE_NULL struct hash<crope>
+{
+  size_t operator()(const crope& __str) const
+  {
+    size_t __size = __str.size();
+
+    if (0 == __size) return 0;
+    return 13*__str[0] + 5*__str[__size - 1] + __size;
+  }
+};
+
+
+__STL_TEMPLATE_NULL struct hash<wrope>
+{
+  size_t operator()(const wrope& __str) const
+  {
+    size_t __size = __str.size();
+
+    if (0 == __size) return 0;
+    return 13*__str[0] + 5*__str[__size - 1] + __size;
+  }
+};
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1174
+#endif
+
+__STL_END_NAMESPACE
+
+# include <ropeimpl.h>
+
+# endif /* __SGI_STL_INTERNAL_ROPE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_set.h b/gnu/egcs/libstdc++/stl/stl_set.h
new file mode 100644
index 00000000000..003069cb074
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_set.h
@@ -0,0 +1,216 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_SET_H
+#define __SGI_STL_INTERNAL_SET_H
+
+__STL_BEGIN_NAMESPACE
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1174
+#pragma set woff 1375
+#endif
+
+#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
+template <class _Key, class _Compare = less<_Key>,
+          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Key) >
+#else
+template <class _Key, class _Compare,
+          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Key) >
+#endif
+class set {
+public:
+  // typedefs:
+
+  typedef _Key     key_type;
+  typedef _Key     value_type;
+  typedef _Compare key_compare;
+  typedef _Compare value_compare;
+private:
+  typedef _Rb_tree<key_type, value_type, 
+                  _Identity<value_type>, key_compare, _Alloc> _Rep_type;
+  _Rep_type _M_t;  // red-black tree representing set
+public:
+  typedef typename _Rep_type::const_pointer pointer;
+  typedef typename _Rep_type::const_pointer const_pointer;
+  typedef typename _Rep_type::const_reference reference;
+  typedef typename _Rep_type::const_reference const_reference;
+  typedef typename _Rep_type::const_iterator iterator;
+  typedef typename _Rep_type::const_iterator const_iterator;
+  typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
+  typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+  typedef typename _Rep_type::size_type size_type;
+  typedef typename _Rep_type::difference_type difference_type;
+  typedef typename _Rep_type::allocator_type allocator_type;
+
+  // allocation/deallocation
+
+  set() : _M_t(_Compare(), allocator_type()) {}
+  explicit set(const _Compare& __comp,
+               const allocator_type& __a = allocator_type())
+    : _M_t(__comp, __a) {}
+
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  set(_InputIterator __first, _InputIterator __last)
+    : _M_t(_Compare(), allocator_type())
+    { _M_t.insert_unique(__first, __last); }
+
+  template <class _InputIterator>
+  set(_InputIterator __first, _InputIterator __last, const _Compare& __comp,
+      const allocator_type& __a = allocator_type())
+    : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); }
+#else
+  set(const value_type* __first, const value_type* __last) 
+    : _M_t(_Compare(), allocator_type()) 
+    { _M_t.insert_unique(__first, __last); }
+
+  set(const value_type* __first, 
+      const value_type* __last, const _Compare& __comp,
+      const allocator_type& __a = allocator_type())
+    : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); }
+
+  set(const_iterator __first, const_iterator __last)
+    : _M_t(_Compare(), allocator_type()) 
+    { _M_t.insert_unique(__first, __last); }
+
+  set(const_iterator __first, const_iterator __last, const _Compare& __comp,
+      const allocator_type& __a = allocator_type())
+    : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); }
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  set(const set<_Key,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {}
+  set<_Key,_Compare,_Alloc>& operator=(const set<_Key, _Compare, _Alloc>& __x)
+  { 
+    _M_t = __x._M_t; 
+    return *this;
+  }
+
+  // accessors:
+
+  key_compare key_comp() const { return _M_t.key_comp(); }
+  value_compare value_comp() const { return _M_t.key_comp(); }
+  allocator_type get_allocator() const { return _M_t.get_allocator(); }
+
+  iterator begin() const { return _M_t.begin(); }
+  iterator end() const { return _M_t.end(); }
+  reverse_iterator rbegin() const { return _M_t.rbegin(); } 
+  reverse_iterator rend() const { return _M_t.rend(); }
+  bool empty() const { return _M_t.empty(); }
+  size_type size() const { return _M_t.size(); }
+  size_type max_size() const { return _M_t.max_size(); }
+  void swap(set<_Key,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }
+
+  // insert/erase
+  pair<iterator,bool> insert(const value_type& __x) { 
+    pair<typename _Rep_type::iterator, bool> __p = _M_t.insert_unique(__x); 
+    return pair<iterator, bool>(__p.first, __p.second);
+  }
+  iterator insert(iterator __position, const value_type& __x) {
+    typedef typename _Rep_type::iterator _Rep_iterator;
+    return _M_t.insert_unique((_Rep_iterator&)__position, __x);
+  }
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  void insert(_InputIterator __first, _InputIterator __last) {
+    _M_t.insert_unique(__first, __last);
+  }
+#else
+  void insert(const_iterator __first, const_iterator __last) {
+    _M_t.insert_unique(__first, __last);
+  }
+  void insert(const value_type* __first, const value_type* __last) {
+    _M_t.insert_unique(__first, __last);
+  }
+#endif /* __STL_MEMBER_TEMPLATES */
+  void erase(iterator __position) { 
+    typedef typename _Rep_type::iterator _Rep_iterator;
+    _M_t.erase((_Rep_iterator&)__position); 
+  }
+  size_type erase(const key_type& __x) { 
+    return _M_t.erase(__x); 
+  }
+  void erase(iterator __first, iterator __last) { 
+    typedef typename _Rep_type::iterator _Rep_iterator;
+    _M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last); 
+  }
+  void clear() { _M_t.clear(); }
+
+  // set operations:
+
+  iterator find(const key_type& __x) const { return _M_t.find(__x); }
+  size_type count(const key_type& __x) const { return _M_t.count(__x); }
+  iterator lower_bound(const key_type& __x) const {
+    return _M_t.lower_bound(__x);
+  }
+  iterator upper_bound(const key_type& __x) const {
+    return _M_t.upper_bound(__x); 
+  }
+  pair<iterator,iterator> equal_range(const key_type& __x) const {
+    return _M_t.equal_range(__x);
+  }
+  friend bool operator== __STL_NULL_TMPL_ARGS (const set&, const set&);
+  friend bool operator< __STL_NULL_TMPL_ARGS (const set&, const set&);
+};
+
+template <class _Key, class _Compare, class _Alloc>
+inline bool operator==(const set<_Key,_Compare,_Alloc>& __x, 
+                       const set<_Key,_Compare,_Alloc>& __y) {
+  return __x._M_t == __y._M_t;
+}
+
+template <class _Key, class _Compare, class _Alloc>
+inline bool operator<(const set<_Key,_Compare,_Alloc>& __x, 
+                      const set<_Key,_Compare,_Alloc>& __y) {
+  return __x._M_t < __y._M_t;
+}
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+
+template <class _Key, class _Compare, class _Alloc>
+inline void swap(set<_Key,_Compare,_Alloc>& __x, 
+                 set<_Key,_Compare,_Alloc>& __y) {
+  __x.swap(__y);
+}
+
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1174
+#pragma reset woff 1375
+#endif
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_SET_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_slist.h b/gnu/egcs/libstdc++/stl/stl_slist.h
new file mode 100644
index 00000000000..6da234d92c2
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_slist.h
@@ -0,0 +1,945 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_SLIST_H
+#define __SGI_STL_INTERNAL_SLIST_H
+
+
+__STL_BEGIN_NAMESPACE 
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1174
+#pragma set woff 1375
+#endif
+
+struct _Slist_node_base
+{
+  _Slist_node_base* _M_next;
+};
+
+inline _Slist_node_base*
+__slist_make_link(_Slist_node_base* __prev_node,
+                  _Slist_node_base* __new_node)
+{
+  __new_node->_M_next = __prev_node->_M_next;
+  __prev_node->_M_next = __new_node;
+  return __new_node;
+}
+
+inline _Slist_node_base* 
+__slist_previous(_Slist_node_base* __head,
+                 const _Slist_node_base* __node)
+{
+  while (__head && __head->_M_next != __node)
+    __head = __head->_M_next;
+  return __head;
+}
+
+inline const _Slist_node_base* 
+__slist_previous(const _Slist_node_base* __head,
+                 const _Slist_node_base* __node)
+{
+  while (__head && __head->_M_next != __node)
+    __head = __head->_M_next;
+  return __head;
+}
+
+inline void __slist_splice_after(_Slist_node_base* __pos,
+                                 _Slist_node_base* __before_first,
+                                 _Slist_node_base* __before_last)
+{
+  if (__pos != __before_first && __pos != __before_last) {
+    _Slist_node_base* __first = __before_first->_M_next;
+    _Slist_node_base* __after = __pos->_M_next;
+    __before_first->_M_next = __before_last->_M_next;
+    __pos->_M_next = __first;
+    __before_last->_M_next = __after;
+  }
+}
+
+inline _Slist_node_base* __slist_reverse(_Slist_node_base* __node)
+{
+  _Slist_node_base* __result = __node;
+  __node = __node->_M_next;
+  __result->_M_next = 0;
+  while(__node) {
+    _Slist_node_base* __next = __node->_M_next;
+    __node->_M_next = __result;
+    __result = __node;
+    __node = __next;
+  }
+  return __result;
+}
+
+inline size_t __slist_size(_Slist_node_base* __node)
+{
+  size_t __result = 0;
+  for ( ; __node != 0; __node = __node->_M_next)
+    ++__result;
+  return __result;
+}
+
+template <class _Tp>
+struct _Slist_node : public _Slist_node_base
+{
+  _Tp _M_data;
+};
+
+struct _Slist_iterator_base
+{
+  typedef size_t               size_type;
+  typedef ptrdiff_t            difference_type;
+  typedef forward_iterator_tag iterator_category;
+
+  _Slist_node_base* _M_node;
+
+  _Slist_iterator_base(_Slist_node_base* __x) : _M_node(__x) {}
+  void _M_incr() { _M_node = _M_node->_M_next; }
+
+  bool operator==(const _Slist_iterator_base& __x) const {
+    return _M_node == __x._M_node;
+  }
+  bool operator!=(const _Slist_iterator_base& __x) const {
+    return _M_node != __x._M_node;
+  }
+};
+
+template <class _Tp, class _Ref, class _Ptr>
+struct _Slist_iterator : public _Slist_iterator_base
+{
+  typedef _Slist_iterator<_Tp, _Tp&, _Tp*>             iterator;
+  typedef _Slist_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
+  typedef _Slist_iterator<_Tp, _Ref, _Ptr>             _Self;
+
+  typedef _Tp              value_type;
+  typedef _Ptr             pointer;
+  typedef _Ref             reference;
+  typedef _Slist_node<_Tp> _Node;
+
+  _Slist_iterator(_Node* __x) : _Slist_iterator_base(__x) {}
+  _Slist_iterator() : _Slist_iterator_base(0) {}
+  _Slist_iterator(const iterator& __x) : _Slist_iterator_base(__x._M_node) {}
+
+  reference operator*() const { return ((_Node*) _M_node)->_M_data; }
+#ifndef __SGI_STL_NO_ARROW_OPERATOR
+  pointer operator->() const { return &(operator*()); }
+#endif /* __SGI_STL_NO_ARROW_OPERATOR */
+
+  _Self& operator++()
+  {
+    _M_incr();
+    return *this;
+  }
+  _Self operator++(int)
+  {
+    _Self __tmp = *this;
+    _M_incr();
+    return __tmp;
+  }
+};
+
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+inline ptrdiff_t* distance_type(const _Slist_iterator_base&) {
+  return 0;
+}
+
+inline forward_iterator_tag iterator_category(const _Slist_iterator_base&) {
+  return forward_iterator_tag();
+}
+
+template <class _Tp, class _Ref, class _Ptr> 
+inline _Tp* value_type(const _Slist_iterator<_Tp, _Ref, _Ptr>&) {
+  return 0;
+}
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+// Base class that encapsulates details of allocators.  Three cases:
+// an ordinary standard-conforming allocator, a standard-conforming
+// allocator with no non-static data, and an SGI-style allocator.
+// This complexity is necessary only because we're worrying about backward
+// compatibility and because we want to avoid wasting storage on an 
+// allocator instance if it isn't necessary.
+
+#ifdef __STL_USE_STD_ALLOCATORS
+
+// Base for general standard-conforming allocators.
+template <class _Tp, class _Allocator, bool _IsStatic>
+class _Slist_alloc_base {
+public:
+  typedef typename _Alloc_traits<_Tp,_Allocator>::allocator_type
+          allocator_type;
+  allocator_type get_allocator() const { return _M_node_allocator; }
+
+  _Slist_alloc_base(const allocator_type& __a) : _M_node_allocator(__a) {}
+
+protected:
+  _Slist_node<_Tp>* _M_get_node() 
+    { return _M_node_allocator.allocate(1); }
+  void _M_put_node(_Slist_node<_Tp>* __p) 
+    { _M_node_allocator.deallocate(__p, 1); }
+
+protected:
+  typename _Alloc_traits<_Slist_node<_Tp>,_Allocator>::allocator_type
+           _M_node_allocator;
+  _Slist_node_base _M_head;
+};
+
+// Specialization for instanceless allocators.
+template <class _Tp, class _Allocator>
+class _Slist_alloc_base<_Tp,_Allocator, true> {
+public:
+  typedef typename _Alloc_traits<_Tp,_Allocator>::allocator_type
+          allocator_type;
+  allocator_type get_allocator() const { return allocator_type(); }
+
+  _Slist_alloc_base(const allocator_type&) {}
+
+protected:
+  typedef typename _Alloc_traits<_Slist_node<_Tp>, _Allocator>::_Alloc_type
+          _Alloc_type;
+  _Slist_node<_Tp>* _M_get_node() { return _Alloc_type::allocate(1); }
+  void _M_put_node(_Slist_node<_Tp>* __p) { _Alloc_type::deallocate(__p, 1); }
+
+protected:
+  _Slist_node_base _M_head;
+};
+
+
+template <class _Tp, class _Alloc>
+struct _Slist_base
+  : public _Slist_alloc_base<_Tp, _Alloc,
+                             _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
+{
+  typedef _Slist_alloc_base<_Tp, _Alloc,
+                            _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
+          _Base;
+  typedef typename _Base::allocator_type allocator_type;
+
+  _Slist_base(const allocator_type& __a) : _Base(__a) { _M_head._M_next = 0; }
+  ~_Slist_base() { _M_erase_after(&_M_head, 0); }
+
+protected:
+
+  _Slist_node_base* _M_erase_after(_Slist_node_base* __pos)
+  {
+    _Slist_node<_Tp>* __next = (_Slist_node<_Tp>*) (__pos->_M_next);
+    _Slist_node_base* __next_next = __next->_M_next;
+    __pos->_M_next = __next_next;
+    destroy(&__next->_M_data);
+    _M_put_node(__next);
+    return __next_next;
+  }
+  _Slist_node_base* _M_erase_after(_Slist_node_base*, _Slist_node_base*);
+};
+
+#else /* __STL_USE_STD_ALLOCATORS */
+
+template <class _Tp, class _Alloc> 
+struct _Slist_base {
+  typedef _Alloc allocator_type;
+  allocator_type get_allocator() const { return allocator_type(); }
+
+  _Slist_base(const allocator_type&) { _M_head._M_next = 0; }
+  ~_Slist_base() { _M_erase_after(&_M_head, 0); }
+
+protected:
+  typedef simple_alloc<_Slist_node<_Tp>, _Alloc> _Alloc_type;
+  _Slist_node<_Tp>* _M_get_node() { return _Alloc_type::allocate(1); }
+  void _M_put_node(_Slist_node<_Tp>* __p) { _Alloc_type::deallocate(__p, 1); }
+
+  _Slist_node_base* _M_erase_after(_Slist_node_base* __pos)
+  {
+    _Slist_node<_Tp>* __next = (_Slist_node<_Tp>*) (__pos->_M_next);
+    _Slist_node_base* __next_next = __next->_M_next;
+    __pos->_M_next = __next_next;
+    destroy(&__next->_M_data);
+    _M_put_node(__next);
+    return __next_next;
+  }
+  _Slist_node_base* _M_erase_after(_Slist_node_base*, _Slist_node_base*);
+
+protected:
+  _Slist_node_base _M_head;
+};  
+
+#endif /* __STL_USE_STD_ALLOCATORS */
+
+template <class _Tp, class _Alloc> 
+_Slist_node_base*
+_Slist_base<_Tp,_Alloc>::_M_erase_after(_Slist_node_base* __before_first,
+                                        _Slist_node_base* __last_node) {
+  _Slist_node<_Tp>* __cur = (_Slist_node<_Tp>*) (__before_first->_M_next);
+  while (__cur != __last_node) {
+    _Slist_node<_Tp>* __tmp = __cur;
+    __cur = (_Slist_node<_Tp>*) __cur->_M_next;
+    destroy(&__tmp->_M_data);
+    _M_put_node(__tmp);
+  }
+  __before_first->_M_next = __last_node;
+  return __last_node;
+}
+
+template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
+class slist : private _Slist_base<_Tp,_Alloc>
+{
+private:
+  typedef _Slist_base<_Tp,_Alloc> _Base;
+public:
+  typedef _Tp                value_type;
+  typedef value_type*       pointer;
+  typedef const value_type* const_pointer;
+  typedef value_type&       reference;
+  typedef const value_type& const_reference;
+  typedef size_t            size_type;
+  typedef ptrdiff_t         difference_type;
+
+  typedef _Slist_iterator<_Tp, _Tp&, _Tp*>             iterator;
+  typedef _Slist_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
+
+  typedef typename _Base::allocator_type allocator_type;
+  allocator_type get_allocator() const { return _Base::get_allocator(); }
+
+private:
+  typedef _Slist_node<_Tp>      _Node;
+  typedef _Slist_node_base      _Node_base;
+  typedef _Slist_iterator_base  _Iterator_base;
+
+  _Node* _M_create_node(const value_type& __x) {
+    _Node* __node = _M_get_node();
+    __STL_TRY {
+      construct(&__node->_M_data, __x);
+      __node->_M_next = 0;
+    }
+    __STL_UNWIND(_M_put_node(__node));
+    return __node;
+  }
+  
+  _Node* _M_create_node() {
+    _Node* __node = _M_get_node();
+    __STL_TRY {
+      construct(&__node->_M_data);
+      __node->_M_next = 0;
+    }
+    __STL_UNWIND(_M_put_node(__node));
+    return __node;
+  }
+
+private:
+#ifdef __STL_USE_NAMESPACES  
+  using _Base::_M_get_node;
+  using _Base::_M_put_node;
+  using _Base::_M_erase_after;
+  using _Base::_M_head;
+#endif /* __STL_USE_NAMESPACES */
+
+public:
+  explicit slist(const allocator_type& __a = allocator_type()) : _Base(__a) {}
+
+  slist(size_type __n, const value_type& __x,
+        const allocator_type& __a =  allocator_type()) : _Base(__a)
+    { _M_insert_after_fill(&_M_head, __n, __x); }
+
+  explicit slist(size_type __n) : _Base(allocator_type())
+    { _M_insert_after_fill(&_M_head, __n, value_type()); }
+
+#ifdef __STL_MEMBER_TEMPLATES
+  // We don't need any dispatching tricks here, because _M_insert_after_range
+  // already does them.
+  template <class _InputIterator>
+  slist(_InputIterator __first, _InputIterator __last,
+        const allocator_type& __a =  allocator_type()) : _Base(__a)
+    { _M_insert_after_range(&_M_head, __first, __last); }
+
+#else /* __STL_MEMBER_TEMPLATES */
+  slist(const_iterator __first, const_iterator __last,
+        const allocator_type& __a =  allocator_type()) : _Base(__a)
+    { _M_insert_after_range(&_M_head, __first, __last); }
+  slist(const value_type* __first, const value_type* __last,
+        const allocator_type& __a =  allocator_type()) : _Base(__a)
+    { _M_insert_after_range(&_M_head, __first, __last); }
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  slist(const slist& __x) : _Base(__x.get_allocator())
+    { _M_insert_after_range(&_M_head, __x.begin(), __x.end()); }
+
+  slist& operator= (const slist& __x);
+
+  ~slist() {}
+
+public:
+  // assign(), a generalized assignment member function.  Two
+  // versions: one that takes a count, and one that takes a range.
+  // The range version is a member template, so we dispatch on whether
+  // or not the type is an integer.
+
+  void assign(size_type __n, const _Tp& __val);
+
+#ifdef __STL_MEMBER_TEMPLATES
+
+  template <class _InputIterator>
+  void assign(_InputIterator __first, _InputIterator __last) {
+    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
+    _M_assign_dispatch(__first, __last, _Integral());
+  }
+
+  template <class _Integer>
+  void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+    { assign((size_type) __n, (_Tp) __val); }
+
+  template <class _InputIterator>
+  void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+                          __false_type);
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+public:
+
+  iterator begin() { return iterator((_Node*)_M_head._M_next); }
+  const_iterator begin() const 
+    { return const_iterator((_Node*)_M_head._M_next);}
+
+  iterator end() { return iterator(0); }
+  const_iterator end() const { return const_iterator(0); }
+
+  size_type size() const { return __slist_size(_M_head._M_next); }
+  
+  size_type max_size() const { return size_type(-1); }
+
+  bool empty() const { return _M_head._M_next == 0; }
+
+  void swap(slist& __x) { __STD::swap(_M_head._M_next, __x._M_head._M_next); }
+
+public:
+  friend bool operator== __STL_NULL_TMPL_ARGS (const slist<_Tp,_Alloc>& _SL1,
+                                               const slist<_Tp,_Alloc>& _SL2);
+
+public:
+
+  reference front() { return ((_Node*) _M_head._M_next)->_M_data; }
+  const_reference front() const 
+    { return ((_Node*) _M_head._M_next)->_M_data; }
+  void push_front(const value_type& __x)   {
+    __slist_make_link(&_M_head, _M_create_node(__x));
+  }
+  void push_front() { __slist_make_link(&_M_head, _M_create_node());}
+  void pop_front() {
+    _Node* __node = (_Node*) _M_head._M_next;
+    _M_head._M_next = __node->_M_next;
+    destroy(&__node->_M_data);
+    _M_put_node(__node);
+  }
+
+  iterator previous(const_iterator __pos) {
+    return iterator((_Node*) __slist_previous(&_M_head, __pos._M_node));
+  }
+  const_iterator previous(const_iterator __pos) const {
+    return const_iterator((_Node*) __slist_previous(&_M_head, __pos._M_node));
+  }
+
+private:
+  _Node* _M_insert_after(_Node_base* __pos, const value_type& __x) {
+    return (_Node*) (__slist_make_link(__pos, _M_create_node(__x)));
+  }
+
+  _Node* _M_insert_after(_Node_base* __pos) {
+    return (_Node*) (__slist_make_link(__pos, _M_create_node()));
+  }
+
+  void _M_insert_after_fill(_Node_base* __pos,
+                            size_type __n, const value_type& __x) {
+    for (size_type __i = 0; __i < __n; ++__i)
+      __pos = __slist_make_link(__pos, _M_create_node(__x));
+  }
+
+#ifdef __STL_MEMBER_TEMPLATES
+
+  // Check whether it's an integral type.  If so, it's not an iterator.
+  template <class _InIter>
+  void _M_insert_after_range(_Node_base* __pos, 
+                             _InIter __first, _InIter __last) {
+    typedef typename _Is_integer<_InIter>::_Integral _Integral;
+    _M_insert_after_range(__pos, __first, __last, _Integral());
+  }
+
+  template <class _Integer>
+  void _M_insert_after_range(_Node_base* __pos, _Integer __n, _Integer __x,
+                             __true_type) {
+    _M_insert_after_fill(__pos, __n, __x);
+  }
+
+  template <class _InIter>
+  void _M_insert_after_range(_Node_base* __pos,
+                             _InIter __first, _InIter __last,
+                             __false_type) {
+    while (__first != __last) {
+      __pos = __slist_make_link(__pos, _M_create_node(*__first));
+      ++__first;
+    }
+  }
+
+#else /* __STL_MEMBER_TEMPLATES */
+
+  void _M_insert_after_range(_Node_base* __pos,
+                             const_iterator __first, const_iterator __last) {
+    while (__first != __last) {
+      __pos = __slist_make_link(__pos, _M_create_node(*__first));
+      ++__first;
+    }
+  }
+  void _M_insert_after_range(_Node_base* __pos,
+                             const value_type* __first,
+                             const value_type* __last) {
+    while (__first != __last) {
+      __pos = __slist_make_link(__pos, _M_create_node(*__first));
+      ++__first;
+    }
+  }
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+public:
+
+  iterator insert_after(iterator __pos, const value_type& __x) {
+    return iterator(_M_insert_after(__pos._M_node, __x));
+  }
+
+  iterator insert_after(iterator __pos) {
+    return insert_after(__pos, value_type());
+  }
+
+  void insert_after(iterator __pos, size_type __n, const value_type& __x) {
+    _M_insert_after_fill(__pos._M_node, __n, __x);
+  }
+
+#ifdef __STL_MEMBER_TEMPLATES
+
+  // We don't need any dispatching tricks here, because _M_insert_after_range
+  // already does them.
+  template <class _InIter>
+  void insert_after(iterator __pos, _InIter __first, _InIter __last) {
+    _M_insert_after_range(__pos._M_node, __first, __last);
+  }
+
+#else /* __STL_MEMBER_TEMPLATES */
+
+  void insert_after(iterator __pos,
+                    const_iterator __first, const_iterator __last) {
+    _M_insert_after_range(__pos._M_node, __first, __last);
+  }
+  void insert_after(iterator __pos,
+                    const value_type* __first, const value_type* __last) {
+    _M_insert_after_range(__pos._M_node, __first, __last);
+  }
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  iterator insert(iterator __pos, const value_type& __x) {
+    return iterator(_M_insert_after(__slist_previous(&_M_head, __pos._M_node),
+                    __x));
+  }
+
+  iterator insert(iterator __pos) {
+    return iterator(_M_insert_after(__slist_previous(&_M_head, __pos._M_node),
+                                    value_type()));
+  }
+
+  void insert(iterator __pos, size_type __n, const value_type& __x) {
+    _M_insert_after_fill(__slist_previous(&_M_head, __pos._M_node), __n, __x);
+  } 
+    
+#ifdef __STL_MEMBER_TEMPLATES
+
+  // We don't need any dispatching tricks here, because _M_insert_after_range
+  // already does them.
+  template <class _InIter>
+  void insert(iterator __pos, _InIter __first, _InIter __last) {
+    _M_insert_after_range(__slist_previous(&_M_head, __pos._M_node), 
+                          __first, __last);
+  }
+
+#else /* __STL_MEMBER_TEMPLATES */
+
+  void insert(iterator __pos, const_iterator __first, const_iterator __last) {
+    _M_insert_after_range(__slist_previous(&_M_head, __pos._M_node), 
+                          __first, __last);
+  }
+  void insert(iterator __pos, const value_type* __first, 
+                              const value_type* __last) {
+    _M_insert_after_range(__slist_previous(&_M_head, __pos._M_node), 
+                          __first, __last);
+  }
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+
+public:
+  iterator erase_after(iterator __pos) {
+    return iterator((_Node*) _M_erase_after(__pos._M_node));
+  }
+  iterator erase_after(iterator __before_first, iterator __last) {
+    return iterator((_Node*) _M_erase_after(__before_first._M_node, 
+                                            __last._M_node));
+  } 
+
+  iterator erase(iterator __pos) {
+    return (_Node*) _M_erase_after(__slist_previous(&_M_head, 
+                                                    __pos._M_node));
+  }
+  iterator erase(iterator __first, iterator __last) {
+    return (_Node*) _M_erase_after(
+      __slist_previous(&_M_head, __first._M_node), __last._M_node);
+  }
+
+  void resize(size_type new_size, const _Tp& __x);
+  void resize(size_type new_size) { resize(new_size, _Tp()); }
+  void clear() { _M_erase_after(&_M_head, 0); }
+
+public:
+  // Moves the range [__before_first + 1, __before_last + 1) to *this,
+  //  inserting it immediately after __pos.  This is constant time.
+  void splice_after(iterator __pos, 
+                    iterator __before_first, iterator __before_last)
+  {
+    if (__before_first != __before_last) 
+      __slist_splice_after(__pos._M_node, __before_first._M_node, 
+                           __before_last._M_node);
+  }
+
+  // Moves the element that follows __prev to *this, inserting it immediately
+  //  after __pos.  This is constant time.
+  void splice_after(iterator __pos, iterator __prev)
+  {
+    __slist_splice_after(__pos._M_node,
+                         __prev._M_node, __prev._M_node->_M_next);
+  }
+
+
+  // Linear in distance(begin(), __pos), and linear in __x.size().
+  void splice(iterator __pos, slist& __x) {
+    if (__x._M_head._M_next)
+      __slist_splice_after(__slist_previous(&_M_head, __pos._M_node),
+                           &__x._M_head, __slist_previous(&__x._M_head, 0));
+  }
+
+  // Linear in distance(begin(), __pos), and in distance(__x.begin(), __i).
+  void splice(iterator __pos, slist& __x, iterator __i) {
+    __slist_splice_after(__slist_previous(&_M_head, __pos._M_node),
+                         __slist_previous(&__x._M_head, __i._M_node),
+                         __i._M_node);
+  }
+
+  // Linear in distance(begin(), __pos), in distance(__x.begin(), __first),
+  // and in distance(__first, __last).
+  void splice(iterator __pos, slist& __x, iterator __first, iterator __last)
+  {
+    if (__first != __last)
+      __slist_splice_after(__slist_previous(&_M_head, __pos._M_node),
+                           __slist_previous(&__x._M_head, __first._M_node),
+                           __slist_previous(__first._M_node, __last._M_node));
+  }
+
+public:
+  void reverse() { 
+    if (_M_head._M_next)
+      _M_head._M_next = __slist_reverse(_M_head._M_next);
+  }
+
+  void remove(const _Tp& __val); 
+  void unique(); 
+  void merge(slist& __x);
+  void sort();     
+
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _Predicate> 
+  void remove_if(_Predicate __pred);
+
+  template <class _BinaryPredicate> 
+  void unique(_BinaryPredicate __pred); 
+
+  template <class _StrictWeakOrdering> 
+  void merge(slist&, _StrictWeakOrdering);
+
+  template <class _StrictWeakOrdering> 
+  void sort(_StrictWeakOrdering __comp); 
+#endif /* __STL_MEMBER_TEMPLATES */
+};
+
+template <class _Tp, class _Alloc>
+slist<_Tp,_Alloc>& slist<_Tp,_Alloc>::operator=(const slist<_Tp,_Alloc>& __x)
+{
+  if (&__x != this) {
+    _Node_base* __p1 = &_M_head;
+    _Node* __n1 = (_Node*) _M_head._M_next;
+    const _Node* __n2 = (const _Node*) __x._M_head._M_next;
+    while (__n1 && __n2) {
+      __n1->_M_data = __n2->_M_data;
+      __p1 = __n1;
+      __n1 = (_Node*) __n1->_M_next;
+      __n2 = (const _Node*) __n2->_M_next;
+    }
+    if (__n2 == 0)
+      _M_erase_after(__p1, 0);
+    else
+      _M_insert_after_range(__p1, const_iterator((_Node*)__n2), 
+                                  const_iterator(0));
+  }
+  return *this;
+}
+
+template <class _Tp, class _Alloc>
+void slist<_Tp, _Alloc>::assign(size_type __n, const _Tp& __val) {
+  _Node_base* __prev = &_M_head;
+  _Node* __node = (_Node*) _M_head._M_next;
+  for ( ; __node != 0 && __n > 0 ; --__n) {
+    __node->_M_data = __val;
+    __prev = __node;
+    __node = (_Node*) __node->_M_next;
+  }
+  if (__n > 0)
+    _M_insert_after_fill(__prev, __n, __val);
+  else
+    _M_erase_after(__prev, 0);
+}
+
+#ifdef __STL_MEMBER_TEMPLATES
+
+template <class _Tp, class _Alloc> template <class _InputIter>
+void
+slist<_Tp, _Alloc>::_M_assign_dispatch(_InputIter __first, _InputIter __last,
+                                       __false_type)
+{
+  _Node_base* __prev = &_M_head;
+  _Node* __node = (_Node*) _M_head._M_next;
+  while (__node != 0 && __first != __last) {
+    __node->_M_data = *__first;
+    __prev = __node;
+    __node = (_Node*) __node->_M_next;
+    ++__first;
+  }
+  if (__first != __last)
+    _M_insert_after_range(__prev, __first, __last);
+  else
+    _M_erase_after(__prev, 0);
+}
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+template <class _Tp, class _Alloc>
+inline bool 
+operator==(const slist<_Tp,_Alloc>& _SL1, const slist<_Tp,_Alloc>& _SL2)
+{
+  typedef typename slist<_Tp,_Alloc>::_Node _Node;
+  _Node* __n1 = (_Node*) _SL1._M_head._M_next;
+  _Node* __n2 = (_Node*) _SL2._M_head._M_next;
+  while (__n1 && __n2 && __n1->_M_data == __n2->_M_data) {
+    __n1 = (_Node*) __n1->_M_next;
+    __n2 = (_Node*) __n2->_M_next;
+  }
+  return __n1 == 0 && __n2 == 0;
+}
+
+template <class _Tp, class _Alloc>
+inline bool operator<(const slist<_Tp,_Alloc>& _SL1,
+                      const slist<_Tp,_Alloc>& _SL2)
+{
+  return lexicographical_compare(_SL1.begin(), _SL1.end(), 
+                                 _SL2.begin(), _SL2.end());
+}
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+
+template <class _Tp, class _Alloc>
+inline void swap(slist<_Tp,_Alloc>& __x, slist<_Tp,_Alloc>& __y) {
+  __x.swap(__y);
+}
+
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+
+template <class _Tp, class _Alloc>
+void slist<_Tp,_Alloc>::resize(size_type __len, const _Tp& __x)
+{
+  _Node_base* __cur = &_M_head;
+  while (__cur->_M_next != 0 && __len > 0) {
+    --__len;
+    __cur = __cur->_M_next;
+  }
+  if (__cur->_M_next) 
+    _M_erase_after(__cur, 0);
+  else
+    _M_insert_after_fill(__cur, __len, __x);
+}
+
+template <class _Tp, class _Alloc>
+void slist<_Tp,_Alloc>::remove(const _Tp& __val)
+{
+  _Node_base* __cur = &_M_head;
+  while (__cur && __cur->_M_next) {
+    if (((_Node*) __cur->_M_next)->_M_data == __val)
+      _M_erase_after(__cur);
+    else
+      __cur = __cur->_M_next;
+  }
+}
+
+template <class _Tp, class _Alloc> 
+void slist<_Tp,_Alloc>::unique()
+{
+  _Node_base* __cur = _M_head._M_next;
+  if (__cur) {
+    while (__cur->_M_next) {
+      if (((_Node*)__cur)->_M_data == 
+          ((_Node*)(__cur->_M_next))->_M_data)
+        _M_erase_after(__cur);
+      else
+        __cur = __cur->_M_next;
+    }
+  }
+}
+
+template <class _Tp, class _Alloc>
+void slist<_Tp,_Alloc>::merge(slist<_Tp,_Alloc>& __x)
+{
+  _Node_base* __n1 = &_M_head;
+  while (__n1->_M_next && __x._M_head._M_next) {
+    if (((_Node*) __x._M_head._M_next)->_M_data < 
+        ((_Node*)       __n1->_M_next)->_M_data) 
+      __slist_splice_after(__n1, &__x._M_head, __x._M_head._M_next);
+    __n1 = __n1->_M_next;
+  }
+  if (__x._M_head._M_next) {
+    __n1->_M_next = __x._M_head._M_next;
+    __x._M_head._M_next = 0;
+  }
+}
+
+template <class _Tp, class _Alloc>
+void slist<_Tp,_Alloc>::sort()
+{
+  if (_M_head._M_next && _M_head._M_next->_M_next) {
+    slist __carry;
+    slist __counter[64];
+    int __fill = 0;
+    while (!empty()) {
+      __slist_splice_after(&__carry._M_head, &_M_head, _M_head._M_next);
+      int __i = 0;
+      while (__i < __fill && !__counter[__i].empty()) {
+        __counter[__i].merge(__carry);
+        __carry.swap(__counter[__i]);
+        ++__i;
+      }
+      __carry.swap(__counter[__i]);
+      if (__i == __fill)
+        ++__fill;
+    }
+
+    for (int __i = 1; __i < __fill; ++__i)
+      __counter[__i].merge(__counter[__i-1]);
+    this->swap(__counter[__fill-1]);
+  }
+}
+
+#ifdef __STL_MEMBER_TEMPLATES
+
+template <class _Tp, class _Alloc> 
+template <class _Predicate>
+void slist<_Tp,_Alloc>::remove_if(_Predicate __pred)
+{
+  _Node_base* __cur = &_M_head;
+  while (__cur->_M_next) {
+    if (__pred(((_Node*) __cur->_M_next)->_M_data))
+      _M_erase_after(__cur);
+    else
+      __cur = __cur->_M_next;
+  }
+}
+
+template <class _Tp, class _Alloc> template <class _BinaryPredicate> 
+void slist<_Tp,_Alloc>::unique(_BinaryPredicate __pred)
+{
+  _Node* __cur = (_Node*) _M_head._M_next;
+  if (__cur) {
+    while (__cur->_M_next) {
+      if (__pred(((_Node*)__cur)->_M_data, 
+                 ((_Node*)(__cur->_M_next))->_M_data))
+        _M_erase_after(__cur);
+      else
+        __cur = (_Node*) __cur->_M_next;
+    }
+  }
+}
+
+template <class _Tp, class _Alloc> template <class _StrictWeakOrdering>
+void slist<_Tp,_Alloc>::merge(slist<_Tp,_Alloc>& __x,
+                              _StrictWeakOrdering __comp)
+{
+  _Node_base* __n1 = &_M_head;
+  while (__n1->_M_next && __x._M_head._M_next) {
+    if (__comp(((_Node*) __x._M_head._M_next)->_M_data,
+               ((_Node*)       __n1->_M_next)->_M_data))
+      __slist_splice_after(__n1, &__x._M_head, __x._M_head._M_next);
+    __n1 = __n1->_M_next;
+  }
+  if (__x._M_head._M_next) {
+    __n1->_M_next = __x._M_head._M_next;
+    __x._M_head._M_next = 0;
+  }
+}
+
+template <class _Tp, class _Alloc> template <class _StrictWeakOrdering> 
+void slist<_Tp,_Alloc>::sort(_StrictWeakOrdering __comp)
+{
+  if (_M_head._M_next && _M_head._M_next->_M_next) {
+    slist __carry;
+    slist __counter[64];
+    int __fill = 0;
+    while (!empty()) {
+      __slist_splice_after(&__carry._M_head, &_M_head, _M_head._M_next);
+      int __i = 0;
+      while (__i < __fill && !__counter[__i].empty()) {
+        __counter[__i].merge(__carry, __comp);
+        __carry.swap(__counter[__i]);
+        ++__i;
+      }
+      __carry.swap(__counter[__i]);
+      if (__i == __fill)
+        ++__fill;
+    }
+
+    for (int __i = 1; __i < __fill; ++__i)
+      __counter[__i].merge(__counter[__i-1], __comp);
+    this->swap(__counter[__fill-1]);
+  }
+}
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1174
+#pragma reset woff 1375
+#endif
+
+__STL_END_NAMESPACE 
+
+#endif /* __SGI_STL_INTERNAL_SLIST_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_stack.h b/gnu/egcs/libstdc++/stl/stl_stack.h
new file mode 100644
index 00000000000..2a04b21e507
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_stack.h
@@ -0,0 +1,111 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_STACK_H
+#define __SGI_STL_INTERNAL_STACK_H
+
+__STL_BEGIN_NAMESPACE
+
+#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
+template <class _Tp, class _Sequence = deque<_Tp> >
+#else
+template <class _Tp, class _Sequence>
+#endif
+class stack {
+  friend bool operator== __STL_NULL_TMPL_ARGS (const stack&, const stack&);
+  friend bool operator< __STL_NULL_TMPL_ARGS (const stack&, const stack&);
+public:
+  typedef typename _Sequence::value_type      value_type;
+  typedef typename _Sequence::size_type       size_type;
+  typedef          _Sequence                  container_type;
+
+  typedef typename _Sequence::reference       reference;
+  typedef typename _Sequence::const_reference const_reference;
+protected:
+  _Sequence _M_c;
+public:
+  stack() : _M_c() {}
+  explicit stack(const _Sequence& __s) : _M_c(__s) {}
+
+  bool empty() const { return _M_c.empty(); }
+  size_type size() const { return _M_c.size(); }
+  reference top() { return _M_c.back(); }
+  const_reference top() const { return _M_c.back(); }
+  void push(const value_type& __x) { _M_c.push_back(__x); }
+  void pop() { _M_c.pop_back(); }
+};
+
+template <class _Tp, class _Seq>
+bool operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
+{
+  return __x._M_c == __y._M_c;
+}
+
+template <class _Tp, class _Seq>
+bool operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
+{
+  return __x._M_c < __y._M_c;
+}
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+
+template <class _Tp, class _Seq>
+bool operator!=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
+{
+  return !(__x == __y);
+}
+
+template <class _Tp, class _Seq>
+bool operator>(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
+{
+  return __y < __x;
+}
+
+template <class _Tp, class _Seq>
+bool operator<=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
+{
+  return !(__y < __x);
+}
+
+template <class _Tp, class _Seq>
+bool operator>=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
+{
+  return !(__x < __y);
+}
+
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_STACK_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_tempbuf.h b/gnu/egcs/libstdc++/stl/stl_tempbuf.h
new file mode 100644
index 00000000000..e1b2eadafcb
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_tempbuf.h
@@ -0,0 +1,156 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_TEMPBUF_H
+#define __SGI_STL_INTERNAL_TEMPBUF_H
+
+
+__STL_BEGIN_NAMESPACE
+
+template <class _Tp>
+pair<_Tp*, ptrdiff_t> 
+__get_temporary_buffer(ptrdiff_t __len, _Tp*)
+{
+  if (__len > ptrdiff_t(INT_MAX / sizeof(_Tp)))
+    __len = INT_MAX / sizeof(_Tp);
+
+  while (__len > 0) {
+    _Tp* __tmp = (_Tp*) malloc((size_t)__len * sizeof(_Tp));
+    if (__tmp != 0)
+      return pair<_Tp*, ptrdiff_t>(__tmp, __len);
+    __len /= 2;
+  }
+
+  return pair<_Tp*, ptrdiff_t>((_Tp*)0, 0);
+}
+
+#ifdef __STL_EXPLICIT_FUNCTION_TMPL_ARGS
+
+template <class _Tp>
+inline pair<_Tp*, ptrdiff_t> get_temporary_buffer(ptrdiff_t __len) {
+  return __get_temporary_buffer(__len, (_Tp*) 0);
+}
+
+#endif /* __STL_EXPLICIT_FUNCTION_TMPL_ARGS */
+
+// This overload is not required by the standard; it is an extension.
+// It is supported for backward compatibility with the HP STL, and
+// because not all compilers support the language feature (explicit
+// function template arguments) that is required for the standard
+// version of get_temporary_buffer.
+template <class _Tp>
+inline pair<_Tp*, ptrdiff_t> get_temporary_buffer(ptrdiff_t __len, _Tp*) {
+  return __get_temporary_buffer(__len, (_Tp*) 0);
+}
+
+template <class _Tp>
+void return_temporary_buffer(_Tp* __p) {
+  free(__p);
+}
+
+template <class _ForwardIterator, class _Tp>
+class _Temporary_buffer {
+private:
+  ptrdiff_t  _M_original_len;
+  ptrdiff_t  _M_len;
+  _Tp*       _M_buffer;
+
+  void _M_allocate_buffer() {
+    _M_original_len = _M_len;
+    _M_buffer = 0;
+
+    if (_M_len > (ptrdiff_t)(INT_MAX / sizeof(_Tp)))
+      _M_len = INT_MAX / sizeof(_Tp);
+
+    while (_M_len > 0) {
+      _M_buffer = (_Tp*) malloc(_M_len * sizeof(_Tp));
+      if (_M_buffer)
+        break;
+      _M_len /= 2;
+    }
+  }
+
+  void _M_initialize_buffer(const _Tp&, __true_type) {}
+  void _M_initialize_buffer(const _Tp& val, __false_type) {
+    uninitialized_fill_n(_M_buffer, _M_len, val);
+  }
+
+public:
+  ptrdiff_t size() const { return _M_len; }
+  ptrdiff_t requested_size() const { return _M_original_len; }
+  _Tp* begin() { return _M_buffer; }
+  _Tp* end() { return _M_buffer + _M_len; }
+
+  _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last) {
+    typedef typename __type_traits<_Tp>::has_trivial_default_constructor
+            _Trivial;
+    __STL_TRY {
+      _M_len = 0;
+      distance(__first, __last, _M_len);
+      _M_allocate_buffer();
+      if (_M_len > 0)
+        _M_initialize_buffer(*__first, _Trivial());
+    }
+    __STL_UNWIND(free(_M_buffer); _M_buffer = 0; _M_len = 0);
+  }
+ 
+  ~_Temporary_buffer() {  
+    destroy(_M_buffer, _M_buffer + _M_len);
+    free(_M_buffer);
+  }
+
+private:
+  // Disable copy constructor and assignment operator.
+  _Temporary_buffer(const _Temporary_buffer&) {}
+  void operator=(const _Temporary_buffer&) {}
+};
+
+// Class temporary_buffer is not part of the standard.  It is an extension.
+
+template <class _ForwardIterator, 
+          class _Tp 
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+                    = typename iterator_traits<_ForwardIterator>::value_type
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+         >
+struct temporary_buffer : public _Temporary_buffer<_ForwardIterator, _Tp>
+{
+  temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
+    : _Temporary_buffer<_ForwardIterator, _Tp>(__first, __last) {}
+  ~temporary_buffer() {}
+};
+    
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_TEMPBUF_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_tree.h b/gnu/egcs/libstdc++/stl/stl_tree.h
new file mode 100644
index 00000000000..c82943f568a
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_tree.h
@@ -0,0 +1,1333 @@
+/*
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_TREE_H
+#define __SGI_STL_INTERNAL_TREE_H
+
+/*
+
+Red-black tree class, designed for use in implementing STL
+associative containers (set, multiset, map, and multimap). The
+insertion and deletion algorithms are based on those in Cormen,
+Leiserson, and Rivest, Introduction to Algorithms (MIT Press, 1990),
+except that
+
+(1) the header cell is maintained with links not only to the root
+but also to the leftmost node of the tree, to enable constant time
+begin(), and to the rightmost node of the tree, to enable linear time
+performance when used with the generic set algorithms (set_union,
+etc.);
+
+(2) when a node being deleted has two children its successor node is
+relinked into its place, rather than copied, so that the only
+iterators invalidated are those referring to the deleted node.
+
+*/
+
+#include <stl_algobase.h>
+#include <stl_alloc.h>
+#include <stl_construct.h>
+#include <stl_function.h>
+
+__STL_BEGIN_NAMESPACE 
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1375
+#endif
+
+typedef bool _Rb_tree_Color_type;
+const _Rb_tree_Color_type _S_rb_tree_red = false;
+const _Rb_tree_Color_type _S_rb_tree_black = true;
+
+struct _Rb_tree_node_base
+{
+  typedef _Rb_tree_Color_type _Color_type;
+  typedef _Rb_tree_node_base* _Base_ptr;
+
+  _Color_type _M_color; 
+  _Base_ptr _M_parent;
+  _Base_ptr _M_left;
+  _Base_ptr _M_right;
+
+  static _Base_ptr _S_minimum(_Base_ptr __x)
+  {
+    while (__x->_M_left != 0) __x = __x->_M_left;
+    return __x;
+  }
+
+  static _Base_ptr _S_maximum(_Base_ptr __x)
+  {
+    while (__x->_M_right != 0) __x = __x->_M_right;
+    return __x;
+  }
+};
+
+template <class _Value>
+struct _Rb_tree_node : public _Rb_tree_node_base
+{
+  typedef _Rb_tree_node<_Value>* _Link_type;
+  _Value _M_value_field;
+};
+
+
+struct _Rb_tree_base_iterator
+{
+  typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
+  typedef bidirectional_iterator_tag iterator_category;
+  typedef ptrdiff_t difference_type;
+  _Base_ptr _M_node;
+
+  void _M_increment()
+  {
+    if (_M_node->_M_right != 0) {
+      _M_node = _M_node->_M_right;
+      while (_M_node->_M_left != 0)
+        _M_node = _M_node->_M_left;
+    }
+    else {
+      _Base_ptr __y = _M_node->_M_parent;
+      while (_M_node == __y->_M_right) {
+        _M_node = __y;
+        __y = __y->_M_parent;
+      }
+      if (_M_node->_M_right != __y)
+        _M_node = __y;
+    }
+  }
+
+  void _M_decrement()
+  {
+    if (_M_node->_M_color == _S_rb_tree_red &&
+        _M_node->_M_parent->_M_parent == _M_node)
+      _M_node = _M_node->_M_right;
+    else if (_M_node->_M_left != 0) {
+      _Base_ptr __y = _M_node->_M_left;
+      while (__y->_M_right != 0)
+        __y = __y->_M_right;
+      _M_node = __y;
+    }
+    else {
+      _Base_ptr __y = _M_node->_M_parent;
+      while (_M_node == __y->_M_left) {
+        _M_node = __y;
+        __y = __y->_M_parent;
+      }
+      _M_node = __y;
+    }
+  }
+};
+
+template <class _Value, class _Ref, class _Ptr>
+struct _Rb_tree_iterator : public _Rb_tree_base_iterator
+{
+  typedef _Value value_type;
+  typedef _Ref reference;
+  typedef _Ptr pointer;
+  typedef _Rb_tree_iterator<_Value, _Value&, _Value*>             
+    iterator;
+  typedef _Rb_tree_iterator<_Value, const _Value&, const _Value*> 
+    const_iterator;
+  typedef _Rb_tree_iterator<_Value, _Ref, _Ptr>                   
+    _Self;
+  typedef _Rb_tree_node<_Value>* _Link_type;
+
+  _Rb_tree_iterator() {}
+  _Rb_tree_iterator(_Link_type __x) { _M_node = __x; }
+  _Rb_tree_iterator(const iterator& __it) { _M_node = __it._M_node; }
+
+  reference operator*() const { return _Link_type(_M_node)->_M_value_field; }
+#ifndef __SGI_STL_NO_ARROW_OPERATOR
+  pointer operator->() const { return &(operator*()); }
+#endif /* __SGI_STL_NO_ARROW_OPERATOR */
+
+  _Self& operator++() { _M_increment(); return *this; }
+  _Self operator++(int) {
+    _Self __tmp = *this;
+    _M_increment();
+    return __tmp;
+  }
+    
+  _Self& operator--() { _M_decrement(); return *this; }
+  _Self operator--(int) {
+    _Self __tmp = *this;
+    _M_decrement();
+    return __tmp;
+  }
+};
+
+inline bool operator==(const _Rb_tree_base_iterator& __x,
+                       const _Rb_tree_base_iterator& __y) {
+  return __x._M_node == __y._M_node;
+}
+
+inline bool operator!=(const _Rb_tree_base_iterator& __x,
+                       const _Rb_tree_base_iterator& __y) {
+  return __x._M_node != __y._M_node;
+}
+
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+inline bidirectional_iterator_tag
+iterator_category(const _Rb_tree_base_iterator&) {
+  return bidirectional_iterator_tag();
+}
+
+inline _Rb_tree_base_iterator::difference_type*
+distance_type(const _Rb_tree_base_iterator&) {
+  return (_Rb_tree_base_iterator::difference_type*) 0;
+}
+
+template <class _Value, class _Ref, class _Ptr>
+inline _Value* value_type(const _Rb_tree_iterator<_Value, _Ref, _Ptr>&) {
+  return (_Value*) 0;
+}
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+inline void 
+_Rb_tree_rotate_left(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root)
+{
+  _Rb_tree_node_base* __y = __x->_M_right;
+  __x->_M_right = __y->_M_left;
+  if (__y->_M_left !=0)
+    __y->_M_left->_M_parent = __x;
+  __y->_M_parent = __x->_M_parent;
+
+  if (__x == __root)
+    __root = __y;
+  else if (__x == __x->_M_parent->_M_left)
+    __x->_M_parent->_M_left = __y;
+  else
+    __x->_M_parent->_M_right = __y;
+  __y->_M_left = __x;
+  __x->_M_parent = __y;
+}
+
+inline void 
+_Rb_tree_rotate_right(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root)
+{
+  _Rb_tree_node_base* __y = __x->_M_left;
+  __x->_M_left = __y->_M_right;
+  if (__y->_M_right != 0)
+    __y->_M_right->_M_parent = __x;
+  __y->_M_parent = __x->_M_parent;
+
+  if (__x == __root)
+    __root = __y;
+  else if (__x == __x->_M_parent->_M_right)
+    __x->_M_parent->_M_right = __y;
+  else
+    __x->_M_parent->_M_left = __y;
+  __y->_M_right = __x;
+  __x->_M_parent = __y;
+}
+
+inline void 
+_Rb_tree_rebalance(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root)
+{
+  __x->_M_color = _S_rb_tree_red;
+  while (__x != __root && __x->_M_parent->_M_color == _S_rb_tree_red) {
+    if (__x->_M_parent == __x->_M_parent->_M_parent->_M_left) {
+      _Rb_tree_node_base* __y = __x->_M_parent->_M_parent->_M_right;
+      if (__y && __y->_M_color == _S_rb_tree_red) {
+        __x->_M_parent->_M_color = _S_rb_tree_black;
+        __y->_M_color = _S_rb_tree_black;
+        __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
+        __x = __x->_M_parent->_M_parent;
+      }
+      else {
+        if (__x == __x->_M_parent->_M_right) {
+          __x = __x->_M_parent;
+          _Rb_tree_rotate_left(__x, __root);
+        }
+        __x->_M_parent->_M_color = _S_rb_tree_black;
+        __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
+        _Rb_tree_rotate_right(__x->_M_parent->_M_parent, __root);
+      }
+    }
+    else {
+      _Rb_tree_node_base* __y = __x->_M_parent->_M_parent->_M_left;
+      if (__y && __y->_M_color == _S_rb_tree_red) {
+        __x->_M_parent->_M_color = _S_rb_tree_black;
+        __y->_M_color = _S_rb_tree_black;
+        __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
+        __x = __x->_M_parent->_M_parent;
+      }
+      else {
+        if (__x == __x->_M_parent->_M_left) {
+          __x = __x->_M_parent;
+          _Rb_tree_rotate_right(__x, __root);
+        }
+        __x->_M_parent->_M_color = _S_rb_tree_black;
+        __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
+        _Rb_tree_rotate_left(__x->_M_parent->_M_parent, __root);
+      }
+    }
+  }
+  __root->_M_color = _S_rb_tree_black;
+}
+
+inline _Rb_tree_node_base*
+_Rb_tree_rebalance_for_erase(_Rb_tree_node_base* __z,
+                             _Rb_tree_node_base*& __root,
+                             _Rb_tree_node_base*& __leftmost,
+                             _Rb_tree_node_base*& __rightmost)
+{
+  _Rb_tree_node_base* __y = __z;
+  _Rb_tree_node_base* __x = 0;
+  _Rb_tree_node_base* __x_parent = 0;
+  if (__y->_M_left == 0)     // __z has at most one non-null child. y == z.
+    __x = __y->_M_right;     // __x might be null.
+  else
+    if (__y->_M_right == 0)  // __z has exactly one non-null child. y == z.
+      __x = __y->_M_left;    // __x is not null.
+    else {                   // __z has two non-null children.  Set __y to
+      __y = __y->_M_right;   //   __z's successor.  __x might be null.
+      while (__y->_M_left != 0)
+        __y = __y->_M_left;
+      __x = __y->_M_right;
+    }
+  if (__y != __z) {          // relink y in place of z.  y is z's successor
+    __z->_M_left->_M_parent = __y; 
+    __y->_M_left = __z->_M_left;
+    if (__y != __z->_M_right) {
+      __x_parent = __y->_M_parent;
+      if (__x) __x->_M_parent = __y->_M_parent;
+      __y->_M_parent->_M_left = __x;      // __y must be a child of _M_left
+      __y->_M_right = __z->_M_right;
+      __z->_M_right->_M_parent = __y;
+    }
+    else
+      __x_parent = __y;  
+    if (__root == __z)
+      __root = __y;
+    else if (__z->_M_parent->_M_left == __z)
+      __z->_M_parent->_M_left = __y;
+    else 
+      __z->_M_parent->_M_right = __y;
+    __y->_M_parent = __z->_M_parent;
+    __STD::swap(__y->_M_color, __z->_M_color);
+    __y = __z;
+    // __y now points to node to be actually deleted
+  }
+  else {                        // __y == __z
+    __x_parent = __y->_M_parent;
+    if (__x) __x->_M_parent = __y->_M_parent;   
+    if (__root == __z)
+      __root = __x;
+    else 
+      if (__z->_M_parent->_M_left == __z)
+        __z->_M_parent->_M_left = __x;
+      else
+        __z->_M_parent->_M_right = __x;
+    if (__leftmost == __z) 
+      if (__z->_M_right == 0)        // __z->_M_left must be null also
+        __leftmost = __z->_M_parent;
+    // makes __leftmost == _M_header if __z == __root
+      else
+        __leftmost = _Rb_tree_node_base::_S_minimum(__x);
+    if (__rightmost == __z)  
+      if (__z->_M_left == 0)         // __z->_M_right must be null also
+        __rightmost = __z->_M_parent;  
+    // makes __rightmost == _M_header if __z == __root
+      else                      // __x == __z->_M_left
+        __rightmost = _Rb_tree_node_base::_S_maximum(__x);
+  }
+  if (__y->_M_color != _S_rb_tree_red) { 
+    while (__x != __root && (__x == 0 || __x->_M_color == _S_rb_tree_black))
+      if (__x == __x_parent->_M_left) {
+        _Rb_tree_node_base* __w = __x_parent->_M_right;
+        if (__w->_M_color == _S_rb_tree_red) {
+          __w->_M_color = _S_rb_tree_black;
+          __x_parent->_M_color = _S_rb_tree_red;
+          _Rb_tree_rotate_left(__x_parent, __root);
+          __w = __x_parent->_M_right;
+        }
+        if ((__w->_M_left == 0 || 
+             __w->_M_left->_M_color == _S_rb_tree_black) &&
+            (__w->_M_right == 0 || 
+             __w->_M_right->_M_color == _S_rb_tree_black)) {
+          __w->_M_color = _S_rb_tree_red;
+          __x = __x_parent;
+          __x_parent = __x_parent->_M_parent;
+        } else {
+          if (__w->_M_right == 0 || 
+              __w->_M_right->_M_color == _S_rb_tree_black) {
+            if (__w->_M_left) __w->_M_left->_M_color = _S_rb_tree_black;
+            __w->_M_color = _S_rb_tree_red;
+            _Rb_tree_rotate_right(__w, __root);
+            __w = __x_parent->_M_right;
+          }
+          __w->_M_color = __x_parent->_M_color;
+          __x_parent->_M_color = _S_rb_tree_black;
+          if (__w->_M_right) __w->_M_right->_M_color = _S_rb_tree_black;
+          _Rb_tree_rotate_left(__x_parent, __root);
+          break;
+        }
+      } else {                  // same as above, with _M_right <-> _M_left.
+        _Rb_tree_node_base* __w = __x_parent->_M_left;
+        if (__w->_M_color == _S_rb_tree_red) {
+          __w->_M_color = _S_rb_tree_black;
+          __x_parent->_M_color = _S_rb_tree_red;
+          _Rb_tree_rotate_right(__x_parent, __root);
+          __w = __x_parent->_M_left;
+        }
+        if ((__w->_M_right == 0 || 
+             __w->_M_right->_M_color == _S_rb_tree_black) &&
+            (__w->_M_left == 0 || 
+             __w->_M_left->_M_color == _S_rb_tree_black)) {
+          __w->_M_color = _S_rb_tree_red;
+          __x = __x_parent;
+          __x_parent = __x_parent->_M_parent;
+        } else {
+          if (__w->_M_left == 0 || 
+              __w->_M_left->_M_color == _S_rb_tree_black) {
+            if (__w->_M_right) __w->_M_right->_M_color = _S_rb_tree_black;
+            __w->_M_color = _S_rb_tree_red;
+            _Rb_tree_rotate_left(__w, __root);
+            __w = __x_parent->_M_left;
+          }
+          __w->_M_color = __x_parent->_M_color;
+          __x_parent->_M_color = _S_rb_tree_black;
+          if (__w->_M_left) __w->_M_left->_M_color = _S_rb_tree_black;
+          _Rb_tree_rotate_right(__x_parent, __root);
+          break;
+        }
+      }
+    if (__x) __x->_M_color = _S_rb_tree_black;
+  }
+  return __y;
+}
+
+// Base class to encapsulate the differences between old SGI-style
+// allocators and standard-conforming allocators.  In order to avoid
+// having an empty base class, we arbitrarily move one of rb_tree's
+// data members into the base class.
+
+#ifdef __STL_USE_STD_ALLOCATORS
+
+// _Base for general standard-conforming allocators.
+template <class _Tp, class _Alloc, bool _S_instanceless>
+class _Rb_tree_alloc_base {
+public:
+  typedef typename _Alloc_traits<_Tp, _Alloc>::allocator_type allocator_type;
+  allocator_type get_allocator() const { return _M_node_allocator; }
+
+  _Rb_tree_alloc_base(const allocator_type& __a)
+    : _M_node_allocator(__a), _M_header(0) {}
+
+protected:
+  typename _Alloc_traits<_Rb_tree_node<_Tp>, _Alloc>::allocator_type
+           _M_node_allocator;
+  _Rb_tree_node<_Tp>* _M_header;
+
+  _Rb_tree_node<_Tp>* _M_get_node() 
+    { return _M_node_allocator.allocate(1); }
+  void _M_put_node(_Rb_tree_node<_Tp>* __p) 
+    { _M_node_allocator.deallocate(__p, 1); }
+};
+
+// Specialization for instanceless allocators.
+template <class _Tp, class _Alloc>
+class _Rb_tree_alloc_base<_Tp, _Alloc, true> {
+public:
+  typedef typename _Alloc_traits<_Tp, _Alloc>::allocator_type allocator_type;
+  allocator_type get_allocator() const { return allocator_type(); }
+
+  _Rb_tree_alloc_base(const allocator_type&) : _M_header(0) {}
+
+protected:
+  _Rb_tree_node<_Tp>* _M_header;
+
+  typedef typename _Alloc_traits<_Rb_tree_node<_Tp>, _Alloc>::_Alloc_type
+          _Alloc_type;
+
+  _Rb_tree_node<_Tp>* _M_get_node()
+    { return _Alloc_type::allocate(1); }
+  void _M_put_node(_Rb_tree_node<_Tp>* __p)
+    { _Alloc_type::deallocate(__p, 1); }
+};
+
+template <class _Tp, class _Alloc>
+struct _Rb_tree_base
+  : public _Rb_tree_alloc_base<_Tp, _Alloc,
+                               _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
+{
+  typedef _Rb_tree_alloc_base<_Tp, _Alloc,
+                              _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
+          _Base;
+  typedef typename _Base::allocator_type allocator_type;
+
+  _Rb_tree_base(const allocator_type& __a) 
+    : _Base(__a) { _M_header = _M_get_node(); }
+  ~_Rb_tree_base() { _M_put_node(_M_header); }
+
+};
+
+#else /* __STL_USE_STD_ALLOCATORS */
+
+template <class _Tp, class _Alloc>
+struct _Rb_tree_base
+{
+  typedef _Alloc allocator_type;
+  allocator_type get_allocator() const { return allocator_type(); }
+
+  _Rb_tree_base(const allocator_type&) 
+    : _M_header(0) { _M_header = _M_get_node(); }
+  ~_Rb_tree_base() { _M_put_node(_M_header); }
+
+protected:
+  _Rb_tree_node<_Tp>* _M_header;
+
+  typedef simple_alloc<_Rb_tree_node<_Tp>, _Alloc> _Alloc_type;
+
+  _Rb_tree_node<_Tp>* _M_get_node()
+    { return _Alloc_type::allocate(1); }
+  void _M_put_node(_Rb_tree_node<_Tp>* __p)
+    { _Alloc_type::deallocate(__p, 1); }
+};
+
+#endif /* __STL_USE_STD_ALLOCATORS */
+
+template <class _Key, class _Value, class _KeyOfValue, class _Compare,
+          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Value) >
+class _Rb_tree : protected _Rb_tree_base<_Value, _Alloc> {
+  typedef _Rb_tree_base<_Value, _Alloc> _Base;
+protected:
+  typedef _Rb_tree_node_base* _Base_ptr;
+  typedef _Rb_tree_node<_Value> _Rb_tree_node;
+  typedef _Rb_tree_Color_type _Color_type;
+public:
+  typedef _Key key_type;
+  typedef _Value value_type;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef _Rb_tree_node* _Link_type;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+
+  typedef typename _Base::allocator_type allocator_type;
+  allocator_type get_allocator() const { return _Base::get_allocator(); }
+
+protected:
+#ifdef __STL_USE_NAMESPACES
+  using _Base::_M_get_node;
+  using _Base::_M_put_node;
+  using _Base::_M_header;
+#endif /* __STL_USE_NAMESPACES */
+
+protected:
+
+  _Link_type _M_create_node(const value_type& __x)
+  {
+    _Link_type __tmp = _M_get_node();
+    __STL_TRY {
+      construct(&__tmp->_M_value_field, __x);
+    }
+    __STL_UNWIND(_M_put_node(__tmp));
+    return __tmp;
+  }
+
+  _Link_type _M_clone_node(_Link_type __x)
+  {
+    _Link_type __tmp = _M_create_node(__x->_M_value_field);
+    __tmp->_M_color = __x->_M_color;
+    __tmp->_M_left = 0;
+    __tmp->_M_right = 0;
+    return __tmp;
+  }
+
+  void destroy_node(_Link_type __p)
+  {
+    destroy(&__p->_M_value_field);
+    _M_put_node(__p);
+  }
+
+protected:
+  size_type _M_node_count; // keeps track of size of tree
+  _Compare _M_key_compare;
+
+  _Link_type& _M_root() const 
+    { return (_Link_type&) _M_header->_M_parent; }
+  _Link_type& _M_leftmost() const 
+    { return (_Link_type&) _M_header->_M_left; }
+  _Link_type& _M_rightmost() const 
+    { return (_Link_type&) _M_header->_M_right; }
+
+  static _Link_type& _S_left(_Link_type __x)
+    { return (_Link_type&)(__x->_M_left); }
+  static _Link_type& _S_right(_Link_type __x)
+    { return (_Link_type&)(__x->_M_right); }
+  static _Link_type& _S_parent(_Link_type __x)
+    { return (_Link_type&)(__x->_M_parent); }
+  static reference _S_value(_Link_type __x)
+    { return __x->_M_value_field; }
+  static const _Key& _S_key(_Link_type __x)
+    { return _KeyOfValue()(_S_value(__x)); }
+  static _Color_type& _S_color(_Link_type __x)
+    { return (_Color_type&)(__x->_M_color); }
+
+  static _Link_type& _S_left(_Base_ptr __x)
+    { return (_Link_type&)(__x->_M_left); }
+  static _Link_type& _S_right(_Base_ptr __x)
+    { return (_Link_type&)(__x->_M_right); }
+  static _Link_type& _S_parent(_Base_ptr __x)
+    { return (_Link_type&)(__x->_M_parent); }
+  static reference _S_value(_Base_ptr __x)
+    { return ((_Link_type)__x)->_M_value_field; }
+  static const _Key& _S_key(_Base_ptr __x)
+    { return _KeyOfValue()(_S_value(_Link_type(__x)));} 
+  static _Color_type& _S_color(_Base_ptr __x)
+    { return (_Color_type&)(_Link_type(__x)->_M_color); }
+
+  static _Link_type _S_minimum(_Link_type __x) 
+    { return (_Link_type)  _Rb_tree_node_base::_S_minimum(__x); }
+
+  static _Link_type _S_maximum(_Link_type __x)
+    { return (_Link_type) _Rb_tree_node_base::_S_maximum(__x); }
+
+public:
+  typedef _Rb_tree_iterator<value_type, reference, pointer> iterator;
+  typedef _Rb_tree_iterator<value_type, const_reference, const_pointer> 
+          const_iterator;
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+  typedef reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef reverse_iterator<iterator> reverse_iterator;
+#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+  typedef reverse_bidirectional_iterator<iterator, value_type, reference,
+                                         difference_type>
+          reverse_iterator; 
+  typedef reverse_bidirectional_iterator<const_iterator, value_type,
+                                         const_reference, difference_type>
+          const_reverse_iterator;
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ 
+
+private:
+  iterator _M_insert(_Base_ptr __x, _Base_ptr __y, const value_type& __v);
+  _Link_type _M_copy(_Link_type __x, _Link_type __p);
+  void _M_erase(_Link_type __x);
+
+public:
+                                // allocation/deallocation
+  _Rb_tree()
+    : _Base(allocator_type()), _M_node_count(0), _M_key_compare()
+    { _M_empty_initialize(); }
+
+  _Rb_tree(const _Compare& __comp)
+    : _Base(allocator_type()), _M_node_count(0), _M_key_compare(__comp) 
+    { _M_empty_initialize(); }
+
+  _Rb_tree(const _Compare& __comp, const allocator_type& __a)
+    : _Base(__a), _M_node_count(0), _M_key_compare(__comp) 
+    { _M_empty_initialize(); }
+
+  _Rb_tree(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x) 
+    : _Base(__x.get_allocator()),
+      _M_node_count(0), _M_key_compare(__x._M_key_compare)
+  { 
+    if (__x._M_root() == 0)
+      _M_empty_initialize();
+    else {
+      _S_color(_M_header) = _S_rb_tree_red;
+      _M_root() = _M_copy(__x._M_root(), _M_header);
+      _M_leftmost() = _S_minimum(_M_root());
+      _M_rightmost() = _S_maximum(_M_root());
+    }
+    _M_node_count = __x._M_node_count;
+  }
+  ~_Rb_tree() { clear(); }
+  _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& 
+  operator=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x);
+
+private:
+  void _M_empty_initialize() {
+    _S_color(_M_header) = _S_rb_tree_red; // used to distinguish header from 
+                                          // __root, in iterator.operator++
+    _M_root() = 0;
+    _M_leftmost() = _M_header;
+    _M_rightmost() = _M_header;
+  }
+
+public:    
+                                // accessors:
+  _Compare key_comp() const { return _M_key_compare; }
+  iterator begin() { return _M_leftmost(); }
+  const_iterator begin() const { return _M_leftmost(); }
+  iterator end() { return _M_header; }
+  const_iterator end() const { return _M_header; }
+  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());
+  } 
+  bool empty() const { return _M_node_count == 0; }
+  size_type size() const { return _M_node_count; }
+  size_type max_size() const { return size_type(-1); }
+
+  void swap(_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __t) {
+    __STD::swap(_M_header, __t._M_header);
+    __STD::swap(_M_node_count, __t._M_node_count);
+    __STD::swap(_M_key_compare, __t._M_key_compare);
+  }
+    
+public:
+                                // insert/erase
+  pair<iterator,bool> insert_unique(const value_type& __x);
+  iterator insert_equal(const value_type& __x);
+
+  iterator insert_unique(iterator __position, const value_type& __x);
+  iterator insert_equal(iterator __position, const value_type& __x);
+
+#ifdef __STL_MEMBER_TEMPLATES  
+  template <class _InputIterator>
+  void insert_unique(_InputIterator __first, _InputIterator __last);
+  template <class _InputIterator>
+  void insert_equal(_InputIterator __first, _InputIterator __last);
+#else /* __STL_MEMBER_TEMPLATES */
+  void insert_unique(const_iterator __first, const_iterator __last);
+  void insert_unique(const value_type* __first, const value_type* __last);
+  void insert_equal(const_iterator __first, const_iterator __last);
+  void insert_equal(const value_type* __first, const value_type* __last);
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  void erase(iterator __position);
+  size_type erase(const key_type& __x);
+  void erase(iterator __first, iterator __last);
+  void erase(const key_type* __first, const key_type* __last);
+  void clear() {
+    if (_M_node_count != 0) {
+      _M_erase(_M_root());
+      _M_leftmost() = _M_header;
+      _M_root() = 0;
+      _M_rightmost() = _M_header;
+      _M_node_count = 0;
+    }
+  }      
+
+public:
+                                // set operations:
+  iterator find(const key_type& __x);
+  const_iterator find(const key_type& __x) const;
+  size_type count(const key_type& __x) const;
+  iterator lower_bound(const key_type& __x);
+  const_iterator lower_bound(const key_type& __x) const;
+  iterator upper_bound(const key_type& __x);
+  const_iterator upper_bound(const key_type& __x) const;
+  pair<iterator,iterator> equal_range(const key_type& __x);
+  pair<const_iterator, const_iterator> equal_range(const key_type& __x) const;
+
+public:
+                                // Debugging.
+  bool __rb_verify() const;
+};
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+inline bool 
+operator==(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x, 
+           const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y)
+{
+  return __x.size() == __y.size() &&
+         equal(__x.begin(), __x.end(), __y.begin());
+}
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+inline bool 
+operator<(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x, 
+          const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y)
+{
+  return lexicographical_compare(__x.begin(), __x.end(), 
+                                 __y.begin(), __y.end());
+}
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+inline void 
+swap(_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x, 
+     _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y)
+{
+  __x.swap(__y);
+}
+
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& 
+_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
+  ::operator=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x)
+{
+  if (this != &__x) {
+                                // Note that _Key may be a constant type.
+    clear();
+    _M_node_count = 0;
+    _M_key_compare = __x._M_key_compare;        
+    if (__x._M_root() == 0) {
+      _M_root() = 0;
+      _M_leftmost() = _M_header;
+      _M_rightmost() = _M_header;
+    }
+    else {
+      _M_root() = _M_copy(__x._M_root(), _M_header);
+      _M_leftmost() = _S_minimum(_M_root());
+      _M_rightmost() = _S_maximum(_M_root());
+      _M_node_count = __x._M_node_count;
+    }
+  }
+  return *this;
+}
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator
+_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
+  ::_M_insert(_Base_ptr __x_, _Base_ptr __y_, const _Value& __v)
+{
+  _Link_type __x = (_Link_type) __x_;
+  _Link_type __y = (_Link_type) __y_;
+  _Link_type __z;
+
+  if (__y == _M_header || __x != 0 || 
+      _M_key_compare(_KeyOfValue()(__v), _S_key(__y))) {
+    __z = _M_create_node(__v);
+    _S_left(__y) = __z;               // also makes _M_leftmost() = __z 
+                                      //    when __y == _M_header
+    if (__y == _M_header) {
+      _M_root() = __z;
+      _M_rightmost() = __z;
+    }
+    else if (__y == _M_leftmost())
+      _M_leftmost() = __z;   // maintain _M_leftmost() pointing to min node
+  }
+  else {
+    __z = _M_create_node(__v);
+    _S_right(__y) = __z;
+    if (__y == _M_rightmost())
+      _M_rightmost() = __z;  // maintain _M_rightmost() pointing to max node
+  }
+  _S_parent(__z) = __y;
+  _S_left(__z) = 0;
+  _S_right(__z) = 0;
+  _Rb_tree_rebalance(__z, _M_header->_M_parent);
+  ++_M_node_count;
+  return iterator(__z);
+}
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator
+_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
+  ::insert_equal(const _Value& __v)
+{
+  _Link_type __y = _M_header;
+  _Link_type __x = _M_root();
+  while (__x != 0) {
+    __y = __x;
+    __x = _M_key_compare(_KeyOfValue()(__v), _S_key(__x)) ? 
+            _S_left(__x) : _S_right(__x);
+  }
+  return _M_insert(__x, __y, __v);
+}
+
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+pair<typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator, 
+     bool>
+_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
+  ::insert_unique(const _Value& __v)
+{
+  _Link_type __y = _M_header;
+  _Link_type __x = _M_root();
+  bool __comp = true;
+  while (__x != 0) {
+    __y = __x;
+    __comp = _M_key_compare(_KeyOfValue()(__v), _S_key(__x));
+    __x = __comp ? _S_left(__x) : _S_right(__x);
+  }
+  iterator __j = iterator(__y);   
+  if (__comp)
+    if (__j == begin())     
+      return pair<iterator,bool>(_M_insert(__x, __y, __v), true);
+    else
+      --__j;
+  if (_M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v)))
+    return pair<iterator,bool>(_M_insert(__x, __y, __v), true);
+  return pair<iterator,bool>(__j, false);
+}
+
+
+template <class _Key, class _Val, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator 
+_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>
+  ::insert_unique(iterator __position, const _Val& __v)
+{
+  if (__position._M_node == _M_header->_M_left) { // begin()
+    if (size() > 0 && 
+        _M_key_compare(_KeyOfValue()(__v), _S_key(__position._M_node)))
+      return _M_insert(__position._M_node, __position._M_node, __v);
+    // first argument just needs to be non-null 
+    else
+      return insert_unique(__v).first;
+  } else if (__position._M_node == _M_header) { // end()
+    if (_M_key_compare(_S_key(_M_rightmost()), _KeyOfValue()(__v)))
+      return _M_insert(0, _M_rightmost(), __v);
+    else
+      return insert_unique(__v).first;
+  } else {
+    iterator __before = __position;
+    --__before;
+    if (_M_key_compare(_S_key(__before._M_node), _KeyOfValue()(__v)) 
+        && _M_key_compare(_KeyOfValue()(__v), _S_key(__position._M_node))) {
+      if (_S_right(__before._M_node) == 0)
+        return _M_insert(0, __before._M_node, __v); 
+      else
+        return _M_insert(__position._M_node, __position._M_node, __v);
+    // first argument just needs to be non-null 
+    } else
+      return insert_unique(__v).first;
+  }
+}
+
+template <class _Key, class _Val, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::iterator 
+_Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>
+  ::insert_equal(iterator __position, const _Val& __v)
+{
+  if (__position._M_node == _M_header->_M_left) { // begin()
+    if (size() > 0 && 
+        _M_key_compare(_KeyOfValue()(__v), _S_key(__position._M_node)))
+      return _M_insert(__position._M_node, __position._M_node, __v);
+    // first argument just needs to be non-null 
+    else
+      return insert_equal(__v);
+  } else if (__position._M_node == _M_header) {// end()
+    if (!_M_key_compare(_KeyOfValue()(__v), _S_key(_M_rightmost())))
+      return _M_insert(0, _M_rightmost(), __v);
+    else
+      return insert_equal(__v);
+  } else {
+    iterator __before = __position;
+    --__before;
+    if (!_M_key_compare(_KeyOfValue()(__v), _S_key(__before._M_node))
+        && !_M_key_compare(_S_key(__position._M_node), _KeyOfValue()(__v))) {
+      if (_S_right(__before._M_node) == 0)
+        return _M_insert(0, __before._M_node, __v); 
+      else
+        return _M_insert(__position._M_node, __position._M_node, __v);
+    // first argument just needs to be non-null 
+    } else
+      return insert_equal(__v);
+  }
+}
+
+#ifdef __STL_MEMBER_TEMPLATES  
+
+template <class _Key, class _Val, class _KoV, class _Cmp, class _Alloc>
+  template<class _II>
+void _Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc>
+  ::insert_equal(_II __first, _II __last)
+{
+  for ( ; __first != __last; ++__first)
+    insert_equal(*__first);
+}
+
+template <class _Key, class _Val, class _KoV, class _Cmp, class _Alloc> 
+  template<class _II>
+void _Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc>
+  ::insert_unique(_II __first, _II __last) {
+  for ( ; __first != __last; ++__first)
+    insert_unique(*__first);
+}
+
+#else /* __STL_MEMBER_TEMPLATES */
+
+template <class _Key, class _Val, class _KoV, class _Cmp, class _Alloc>
+void
+_Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc>
+  ::insert_equal(const _Val* __first, const _Val* __last)
+{
+  for ( ; __first != __last; ++__first)
+    insert_equal(*__first);
+}
+
+template <class _Key, class _Val, class _KoV, class _Cmp, class _Alloc>
+void
+_Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc>
+  ::insert_equal(const_iterator __first, const_iterator __last)
+{
+  for ( ; __first != __last; ++__first)
+    insert_equal(*__first);
+}
+
+template <class _Key, class _Val, class _KoV, class _Cmp, class _Alloc>
+void 
+_Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc>
+  ::insert_unique(const _Val* __first, const _Val* __last)
+{
+  for ( ; __first != __last; ++__first)
+    insert_unique(*__first);
+}
+
+template <class _Key, class _Val, class _KoV, class _Cmp, class _Alloc>
+void _Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc>
+  ::insert_unique(const_iterator __first, const_iterator __last)
+{
+  for ( ; __first != __last; ++__first)
+    insert_unique(*__first);
+}
+
+#endif /* __STL_MEMBER_TEMPLATES */
+         
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+inline void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
+  ::erase(iterator __position)
+{
+  _Link_type __y = 
+    (_Link_type) _Rb_tree_rebalance_for_erase(__position._M_node,
+                                              _M_header->_M_parent,
+                                              _M_header->_M_left,
+                                              _M_header->_M_right);
+  destroy_node(__y);
+  --_M_node_count;
+}
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::size_type 
+_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::erase(const _Key& __x)
+{
+  pair<iterator,iterator> __p = equal_range(__x);
+  size_type __n = 0;
+  distance(__p.first, __p.second, __n);
+  erase(__p.first, __p.second);
+  return __n;
+}
+
+template <class _Key, class _Val, class _KoV, class _Compare, class _Alloc>
+typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type 
+_Rb_tree<_Key,_Val,_KoV,_Compare,_Alloc>
+  ::_M_copy(_Link_type __x, _Link_type __p)
+{
+                        // structural copy.  __x and __p must be non-null.
+  _Link_type __top = _M_clone_node(__x);
+  __top->_M_parent = __p;
+ 
+  __STL_TRY {
+    if (__x->_M_right)
+      __top->_M_right = _M_copy(_S_right(__x), __top);
+    __p = __top;
+    __x = _S_left(__x);
+
+    while (__x != 0) {
+      _Link_type __y = _M_clone_node(__x);
+      __p->_M_left = __y;
+      __y->_M_parent = __p;
+      if (__x->_M_right)
+        __y->_M_right = _M_copy(_S_right(__x), __y);
+      __p = __y;
+      __x = _S_left(__x);
+    }
+  }
+  __STL_UNWIND(_M_erase(__top));
+
+  return __top;
+}
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
+  ::_M_erase(_Link_type __x)
+{
+                                // erase without rebalancing
+  while (__x != 0) {
+    _M_erase(_S_right(__x));
+    _Link_type __y = _S_left(__x);
+    destroy_node(__x);
+    __x = __y;
+  }
+}
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
+  ::erase(iterator __first, iterator __last)
+{
+  if (__first == begin() && __last == end())
+    clear();
+  else
+    while (__first != __last) erase(__first++);
+}
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
+  ::erase(const _Key* __first, const _Key* __last) 
+{
+  while (__first != __last) erase(*__first++);
+}
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator 
+_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::find(const _Key& __k)
+{
+  _Link_type __y = _M_header;      // Last node which is not less than __k. 
+  _Link_type __x = _M_root();      // Current node. 
+
+  while (__x != 0) 
+    if (!_M_key_compare(_S_key(__x), __k))
+      __y = __x, __x = _S_left(__x);
+    else
+      __x = _S_right(__x);
+
+  iterator __j = iterator(__y);   
+  return (__j == end() || _M_key_compare(__k, _S_key(__j._M_node))) ? 
+     end() : __j;
+}
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::const_iterator 
+_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::find(const _Key& __k) const
+{
+  _Link_type __y = _M_header; /* Last node which is not less than __k. */
+  _Link_type __x = _M_root(); /* Current node. */
+
+  while (__x != 0) {
+    if (!_M_key_compare(_S_key(__x), __k))
+      __y = __x, __x = _S_left(__x);
+    else
+      __x = _S_right(__x);
+  }
+  const_iterator __j = const_iterator(__y);   
+  return (__j == end() || _M_key_compare(__k, _S_key(__j._M_node))) ?
+    end() : __j;
+}
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::size_type 
+_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
+  ::count(const _Key& __k) const
+{
+  pair<const_iterator, const_iterator> __p = equal_range(__k);
+  size_type __n = 0;
+  distance(__p.first, __p.second, __n);
+  return __n;
+}
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator 
+_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
+  ::lower_bound(const _Key& __k)
+{
+  _Link_type __y = _M_header; /* Last node which is not less than __k. */
+  _Link_type __x = _M_root(); /* Current node. */
+
+  while (__x != 0) 
+    if (!_M_key_compare(_S_key(__x), __k))
+      __y = __x, __x = _S_left(__x);
+    else
+      __x = _S_right(__x);
+
+  return iterator(__y);
+}
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::const_iterator 
+_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
+  ::lower_bound(const _Key& __k) const
+{
+  _Link_type __y = _M_header; /* Last node which is not less than __k. */
+  _Link_type __x = _M_root(); /* Current node. */
+
+  while (__x != 0) 
+    if (!_M_key_compare(_S_key(__x), __k))
+      __y = __x, __x = _S_left(__x);
+    else
+      __x = _S_right(__x);
+
+  return const_iterator(__y);
+}
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator 
+_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
+  ::upper_bound(const _Key& __k)
+{
+  _Link_type __y = _M_header; /* Last node which is greater than __k. */
+  _Link_type __x = _M_root(); /* Current node. */
+
+   while (__x != 0) 
+     if (_M_key_compare(__k, _S_key(__x)))
+       __y = __x, __x = _S_left(__x);
+     else
+       __x = _S_right(__x);
+
+   return iterator(__y);
+}
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::const_iterator 
+_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
+  ::upper_bound(const _Key& __k) const
+{
+  _Link_type __y = _M_header; /* Last node which is greater than __k. */
+  _Link_type __x = _M_root(); /* Current node. */
+
+   while (__x != 0) 
+     if (_M_key_compare(__k, _S_key(__x)))
+       __y = __x, __x = _S_left(__x);
+     else
+       __x = _S_right(__x);
+
+   return const_iterator(__y);
+}
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+inline 
+pair<typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator,
+     typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator>
+_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
+  ::equal_range(const _Key& __k)
+{
+  return pair<iterator, iterator>(lower_bound(__k), upper_bound(__k));
+}
+
+template <class _Key, class _Value, class _KoV, class _Compare, class _Alloc>
+inline 
+pair<typename _Rb_tree<_Key, _Value, _KoV, _Compare, _Alloc>::const_iterator,
+     typename _Rb_tree<_Key, _Value, _KoV, _Compare, _Alloc>::const_iterator>
+_Rb_tree<_Key, _Value, _KoV, _Compare, _Alloc>
+  ::equal_range(const _Key& __k) const
+{
+  return pair<const_iterator,const_iterator>(lower_bound(__k),
+                                             upper_bound(__k));
+}
+
+inline int 
+__black_count(_Rb_tree_node_base* __node, _Rb_tree_node_base* __root)
+{
+  if (__node == 0)
+    return 0;
+  else {
+    int __bc = __node->_M_color == _S_rb_tree_black ? 1 : 0;
+    if (__node == __root)
+      return __bc;
+    else
+      return __bc + __black_count(__node->_M_parent, __root);
+  }
+}
+
+template <class _Key, class _Value, class _KeyOfValue, 
+          class _Compare, class _Alloc>
+bool _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
+{
+  if (_M_node_count == 0 || begin() == end())
+    return _M_node_count == 0 && begin() == end() &&
+      _M_header->_M_left == _M_header && _M_header->_M_right == _M_header;
+  
+  int __len = __black_count(_M_leftmost(), _M_root());
+  for (const_iterator __it = begin(); __it != end(); ++__it) {
+    _Link_type __x = (_Link_type) __it._M_node;
+    _Link_type __L = _S_left(__x);
+    _Link_type __R = _S_right(__x);
+
+    if (__x->_M_color == _S_rb_tree_red)
+      if ((__L && __L->_M_color == _S_rb_tree_red) ||
+          (__R && __R->_M_color == _S_rb_tree_red))
+        return false;
+
+    if (__L && _M_key_compare(_S_key(__x), _S_key(__L)))
+      return false;
+    if (__R && _M_key_compare(_S_key(__R), _S_key(__x)))
+      return false;
+
+    if (!__L && !__R && __black_count(__x, _M_root()) != __len)
+      return false;
+  }
+
+  if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
+    return false;
+  if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
+    return false;
+
+  return true;
+}
+
+// Class rb_tree is not part of the C++ standard.  It is provided for
+// compatibility with the HP STL.
+
+template <class _Key, class _Value, class _KeyOfValue, class _Compare,
+          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Value) >
+struct rb_tree : public _Rb_tree<_Key, _Value, _KeyOfValue, _Compare, _Alloc>
+{
+  typedef _Rb_tree<_Key, _Value, _KeyOfValue, _Compare, _Alloc> _Base;
+  typedef typename _Base::allocator_type allocator_type;
+
+  rb_tree(const _Compare& __comp = _Compare(),
+          const allocator_type& __a = allocator_type())
+    : _Base(__comp, __a) {}
+  
+  ~rb_tree() {}
+};
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1375
+#endif
+
+__STL_END_NAMESPACE 
+
+#endif /* __SGI_STL_INTERNAL_TREE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_uninitialized.h b/gnu/egcs/libstdc++/stl/stl_uninitialized.h
new file mode 100644
index 00000000000..3146c82a71c
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_uninitialized.h
@@ -0,0 +1,279 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_UNINITIALIZED_H
+#define __SGI_STL_INTERNAL_UNINITIALIZED_H
+
+__STL_BEGIN_NAMESPACE
+
+// uninitialized_copy
+
+// Valid if copy construction is equivalent to assignment, and if the
+//  destructor is trivial.
+template <class _InputIter, class _ForwardIter>
+inline _ForwardIter 
+__uninitialized_copy_aux(_InputIter __first, _InputIter __last,
+                         _ForwardIter __result,
+                         __true_type)
+{
+  return copy(__first, __last, __result);
+}
+
+template <class _InputIter, class _ForwardIter>
+_ForwardIter 
+__uninitialized_copy_aux(_InputIter __first, _InputIter __last,
+                         _ForwardIter __result,
+                         __false_type)
+{
+  _ForwardIter __cur = __result;
+  __STL_TRY {
+    for ( ; __first != __last; ++__first, ++__cur)
+      construct(&*__cur, *__first);
+    return __cur;
+  }
+  __STL_UNWIND(destroy(__result, __cur));
+}
+
+
+template <class _InputIter, class _ForwardIter, class _Tp>
+inline _ForwardIter
+__uninitialized_copy(_InputIter __first, _InputIter __last,
+                     _ForwardIter __result, _Tp*)
+{
+  typedef typename __type_traits<_Tp>::is_POD_type _Is_POD;
+  return __uninitialized_copy_aux(__first, __last, __result, _Is_POD());
+}
+
+template <class _InputIter, class _ForwardIter>
+inline _ForwardIter
+  uninitialized_copy(_InputIter __first, _InputIter __last,
+                     _ForwardIter __result)
+{
+  return __uninitialized_copy(__first, __last, __result,
+                              __VALUE_TYPE(__result));
+}
+
+inline char* uninitialized_copy(const char* __first, const char* __last,
+                                char* __result) {
+  memmove(__result, __first, __last - __first);
+  return __result + (__last - __first);
+}
+
+inline wchar_t* 
+uninitialized_copy(const wchar_t* __first, const wchar_t* __last,
+                   wchar_t* __result)
+{
+  memmove(__result, __first, sizeof(wchar_t) * (__last - __first));
+  return __result + (__last - __first);
+}
+
+// uninitialized_copy_n (not part of the C++ standard)
+
+template <class _InputIter, class _Size, class _ForwardIter>
+pair<_InputIter, _ForwardIter>
+__uninitialized_copy_n(_InputIter __first, _Size __count,
+                       _ForwardIter __result,
+                       input_iterator_tag)
+{
+  _ForwardIter __cur = __result;
+  __STL_TRY {
+    for ( ; __count > 0 ; --__count, ++__first, ++__cur) 
+      construct(&*__cur, *__first);
+    return pair<_InputIter, _ForwardIter>(__first, __cur);
+  }
+  __STL_UNWIND(destroy(__result, __cur));
+}
+
+template <class _RandomAccessIter, class _Size, class _ForwardIter>
+inline pair<_RandomAccessIter, _ForwardIter>
+__uninitialized_copy_n(_RandomAccessIter __first, _Size __count,
+                       _ForwardIter __result,
+                       random_access_iterator_tag) {
+  _RandomAccessIter __last = __first + __count;
+  return pair<_RandomAccessIter, _ForwardIter>(
+                 __last,
+                 uninitialized_copy(__first, __last, __result));
+}
+
+template <class _InputIter, class _Size, class _ForwardIter>
+inline pair<_InputIter, _ForwardIter>
+__uninitialized_copy_n(_InputIter __first, _Size __count,
+                     _ForwardIter __result) {
+  return __uninitialized_copy_n(__first, __count, __result,
+                                __ITERATOR_CATEGORY(__first));
+}
+
+template <class _InputIter, class _Size, class _ForwardIter>
+inline pair<_InputIter, _ForwardIter>
+uninitialized_copy_n(_InputIter __first, _Size __count,
+                     _ForwardIter __result) {
+  return __uninitialized_copy_n(__first, __count, __result,
+                                __ITERATOR_CATEGORY(__first));
+}
+
+// Valid if copy construction is equivalent to assignment, and if the
+// destructor is trivial.
+template <class _ForwardIter, class _Tp>
+inline void
+__uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last, 
+                         const _Tp& __x, __true_type)
+{
+  fill(__first, __last, __x);
+}
+
+template <class _ForwardIter, class _Tp>
+void
+__uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last, 
+                         const _Tp& __x, __false_type)
+{
+  _ForwardIter __cur = __first;
+  __STL_TRY {
+    for ( ; __cur != __last; ++__cur)
+      construct(&*__cur, __x);
+  }
+  __STL_UNWIND(destroy(__first, __cur));
+}
+
+template <class _ForwardIter, class _Tp, class _Tp1>
+inline void __uninitialized_fill(_ForwardIter __first, 
+                                 _ForwardIter __last, const _Tp& __x, _Tp1*)
+{
+  typedef typename __type_traits<_Tp1>::is_POD_type _Is_POD;
+  __uninitialized_fill_aux(__first, __last, __x, _Is_POD());
+                   
+}
+
+template <class _ForwardIter, class _Tp>
+inline void uninitialized_fill(_ForwardIter __first,
+                               _ForwardIter __last, 
+                               const _Tp& __x)
+{
+  __uninitialized_fill(__first, __last, __x, __VALUE_TYPE(__first));
+}
+
+// Valid if copy construction is equivalent to assignment, and if the
+//  destructor is trivial.
+template <class _ForwardIter, class _Size, class _Tp>
+inline _ForwardIter
+__uninitialized_fill_n_aux(_ForwardIter __first, _Size __n,
+                           const _Tp& __x, __true_type)
+{
+  return fill_n(__first, __n, __x);
+}
+
+template <class _ForwardIter, class _Size, class _Tp>
+_ForwardIter
+__uninitialized_fill_n_aux(_ForwardIter __first, _Size __n,
+                           const _Tp& __x, __false_type)
+{
+  _ForwardIter __cur = __first;
+  __STL_TRY {
+    for ( ; __n > 0; --__n, ++__cur)
+      construct(&*__cur, __x);
+    return __cur;
+  }
+  __STL_UNWIND(destroy(__first, __cur));
+}
+
+template <class _ForwardIter, class _Size, class _Tp, class _Tp1>
+inline _ForwardIter 
+__uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x, _Tp1*)
+{
+  typedef typename __type_traits<_Tp1>::is_POD_type _Is_POD;
+  return __uninitialized_fill_n_aux(__first, __n, __x, _Is_POD());
+}
+
+template <class _ForwardIter, class _Size, class _Tp>
+inline _ForwardIter 
+uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x)
+{
+  return __uninitialized_fill_n(__first, __n, __x, __VALUE_TYPE(__first));
+}
+
+// Extensions: __uninitialized_copy_copy, __uninitialized_copy_fill, 
+// __uninitialized_fill_copy.
+
+// __uninitialized_copy_copy
+// Copies [first1, last1) into [result, result + (last1 - first1)), and
+//  copies [first2, last2) into
+//  [result, result + (last1 - first1) + (last2 - first2)).
+
+template <class _InputIter1, class _InputIter2, class _ForwardIter>
+inline _ForwardIter
+__uninitialized_copy_copy(_InputIter1 __first1, _InputIter1 __last1,
+                          _InputIter2 __first2, _InputIter2 __last2,
+                          _ForwardIter __result)
+{
+  _ForwardIter __mid = uninitialized_copy(__first1, __last1, __result);
+  __STL_TRY {
+    return uninitialized_copy(__first2, __last2, __mid);
+  }
+  __STL_UNWIND(destroy(__result, __mid));
+}
+
+// __uninitialized_fill_copy
+// Fills [result, mid) with x, and copies [first, last) into
+//  [mid, mid + (last - first)).
+template <class _ForwardIter, class _Tp, class _InputIter>
+inline _ForwardIter 
+__uninitialized_fill_copy(_ForwardIter __result, _ForwardIter __mid,
+                          const _Tp& __x,
+                          _InputIter __first, _InputIter __last)
+{
+  uninitialized_fill(__result, __mid, __x);
+  __STL_TRY {
+    return uninitialized_copy(__first, __last, __mid);
+  }
+  __STL_UNWIND(destroy(__result, __mid));
+}
+
+// __uninitialized_copy_fill
+// Copies [first1, last1) into [first2, first2 + (last1 - first1)), and
+//  fills [first2 + (last1 - first1), last2) with x.
+template <class _InputIter, class _ForwardIter, class _Tp>
+inline void
+__uninitialized_copy_fill(_InputIter __first1, _InputIter __last1,
+                          _ForwardIter __first2, _ForwardIter __last2,
+                          const _Tp& __x)
+{
+  _ForwardIter __mid2 = uninitialized_copy(__first1, __last1, __first2);
+  __STL_TRY {
+    uninitialized_fill(__mid2, __last2, __x);
+  }
+  __STL_UNWIND(destroy(__first2, __mid2));
+}
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_UNINITIALIZED_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/stl_vector.h b/gnu/egcs/libstdc++/stl/stl_vector.h
new file mode 100644
index 00000000000..d1149e9af66
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/stl_vector.h
@@ -0,0 +1,823 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_VECTOR_H
+#define __SGI_STL_INTERNAL_VECTOR_H
+
+__STL_BEGIN_NAMESPACE 
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1174
+#pragma set woff 1375
+#endif
+
+// The vector base class serves two purposes.  First, its constructor
+// and destructor allocate (but don't initialize) storage.  This makes
+// exception safety easier.  Second, the base class encapsulates all of
+// the differences between SGI-style allocators and standard-conforming
+// allocators.
+
+#ifdef __STL_USE_STD_ALLOCATORS
+
+// Base class for ordinary allocators.
+template <class _Tp, class _Allocator, bool _IsStatic>
+class _Vector_alloc_base {
+public:
+  typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
+          allocator_type;
+  allocator_type get_allocator() const { return _M_data_allocator; }
+
+  _Vector_alloc_base(const allocator_type& __a)
+    : _M_data_allocator(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0) 
+  {}
+  
+protected:
+  allocator_type _M_data_allocator;
+  _Tp* _M_start;
+  _Tp* _M_finish;
+  _Tp* _M_end_of_storage;
+
+  _Tp* _M_allocate(size_t __n)
+    { return _M_data_allocator.allocate(__n); }
+  void _M_deallocate(_Tp* __p, size_t __n)
+    { if (__p) _M_data_allocator.deallocate(__p, __n); }
+};
+
+// Specialization for allocators that have the property that we don't
+// actually have to store an allocator object.  
+template <class _Tp, class _Allocator>
+class _Vector_alloc_base<_Tp, _Allocator, true> {
+public:
+  typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
+          allocator_type;
+  allocator_type get_allocator() const { return allocator_type(); }
+
+  _Vector_alloc_base(const allocator_type&)
+    : _M_start(0), _M_finish(0), _M_end_of_storage(0) 
+  {}
+  
+protected:
+  _Tp* _M_start;
+  _Tp* _M_finish;
+  _Tp* _M_end_of_storage;
+
+  typedef typename _Alloc_traits<_Tp, _Allocator>::_Alloc_type _Alloc_type;
+  _Tp* _M_allocate(size_t __n)
+    { return _Alloc_type::allocate(__n); }
+  void _M_deallocate(_Tp* __p, size_t __n)
+    { _Alloc_type::deallocate(__p, __n);}
+};
+
+template <class _Tp, class _Alloc>
+struct _Vector_base
+  : public _Vector_alloc_base<_Tp, _Alloc,
+                              _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
+{
+  typedef _Vector_alloc_base<_Tp, _Alloc, 
+                             _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
+          _Base;
+  typedef typename _Base::allocator_type allocator_type;
+
+  _Vector_base(const allocator_type& __a) : _Base(__a) {}
+  _Vector_base(size_t __n, const allocator_type& __a) : _Base(__a) {
+    _M_start = _M_allocate(__n);
+    _M_finish = _M_start;
+    _M_end_of_storage = _M_start + __n;
+  }
+
+  ~_Vector_base() { _M_deallocate(_M_start, _M_end_of_storage - _M_start); }
+};    
+
+#else /* __STL_USE_STD_ALLOCATORS */
+
+template <class _Tp, class _Alloc> 
+class _Vector_base {
+public:
+  typedef _Alloc allocator_type;
+  allocator_type get_allocator() const { return allocator_type(); }
+
+  _Vector_base(const _Alloc&)
+    : _M_start(0), _M_finish(0), _M_end_of_storage(0) {}
+  _Vector_base(size_t __n, const _Alloc&)
+    : _M_start(0), _M_finish(0), _M_end_of_storage(0) 
+  {
+    _M_start = _M_allocate(__n);
+    _M_finish = _M_start;
+    _M_end_of_storage = _M_start + __n;
+  }
+
+  ~_Vector_base() { _M_deallocate(_M_start, _M_end_of_storage - _M_start); }
+
+protected:
+  _Tp* _M_start;
+  _Tp* _M_finish;
+  _Tp* _M_end_of_storage;
+
+  typedef simple_alloc<_Tp, _Alloc> _M_data_allocator;
+  _Tp* _M_allocate(size_t __n)
+    { return _M_data_allocator::allocate(__n); }
+  void _M_deallocate(_Tp* __p, size_t __n) 
+    { _M_data_allocator::deallocate(__p, __n); }
+};
+
+#endif /* __STL_USE_STD_ALLOCATORS */
+
+template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
+class vector : protected _Vector_base<_Tp, _Alloc> 
+{
+private:
+  typedef _Vector_base<_Tp, _Alloc> _Base;
+public:
+  typedef _Tp value_type;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef value_type* iterator;
+  typedef const value_type* const_iterator;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+
+  typedef typename _Base::allocator_type allocator_type;
+  allocator_type get_allocator() const { return _Base::get_allocator(); }
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+  typedef reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef reverse_iterator<iterator> reverse_iterator;
+#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+  typedef reverse_iterator<const_iterator, value_type, const_reference, 
+                           difference_type>  const_reverse_iterator;
+  typedef reverse_iterator<iterator, value_type, reference, difference_type>
+          reverse_iterator;
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+protected:
+#ifdef __STL_HAS_NAMESPACES
+  using _Base::_M_allocate;
+  using _Base::_M_deallocate;
+  using _Base::_M_start;
+  using _Base::_M_finish;
+  using _Base::_M_end_of_storage;
+#endif /* __STL_HAS_NAMESPACES */
+
+protected:
+  void _M_insert_aux(iterator __position, const _Tp& __x);
+  void _M_insert_aux(iterator __position);
+
+public:
+  iterator begin() { return _M_start; }
+  const_iterator begin() const { return _M_start; }
+  iterator end() { return _M_finish; }
+  const_iterator end() const { return _M_finish; }
+
+  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()); }
+
+  size_type size() const
+    { return size_type(end() - begin()); }
+  size_type max_size() const
+    { return size_type(-1) / sizeof(_Tp); }
+  size_type capacity() const
+    { return size_type(_M_end_of_storage - begin()); }
+  bool empty() const
+    { return begin() == end(); }
+
+  reference operator[](size_type __n) { return *(begin() + __n); }
+  const_reference operator[](size_type __n) const { return *(begin() + __n); }
+
+  explicit vector(const allocator_type& __a = allocator_type())
+    : _Base(__a) {}
+
+  vector(size_type __n, const _Tp& __value,
+         const allocator_type& __a = allocator_type()) 
+    : _Base(__n, __a)
+    { _M_finish = uninitialized_fill_n(_M_start, __n, __value); }
+
+  explicit vector(size_type __n)
+    : _Base(__n, allocator_type())
+    { _M_finish = uninitialized_fill_n(_M_start, __n, _Tp()); }
+
+  vector(const vector<_Tp, _Alloc>& __x) 
+    : _Base(__x.size(), __x.get_allocator())
+    { _M_finish = uninitialized_copy(__x.begin(), __x.end(), _M_start); }
+
+#ifdef __STL_MEMBER_TEMPLATES
+  // Check whether it's an integral type.  If so, it's not an iterator.
+  template <class _InputIterator>
+  vector(_InputIterator __first, _InputIterator __last,
+         const allocator_type& __a = allocator_type()) : _Base(__a) {
+    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
+    _M_initialize_aux(__first, __last, _Integral());
+  }
+
+  template <class _Integer>
+  void _M_initialize_aux(_Integer __n, _Integer __value, __true_type) {
+    _M_start = _M_allocate(__n);
+    _M_end_of_storage = _M_start + __n; 
+    _M_finish = uninitialized_fill_n(_M_start, __n, __value);
+  }
+
+  template <class _InputIterator>
+  void _M_initialize_aux(_InputIterator __first, _InputIterator __last,
+                         __false_type) {
+    _M_range_initialize(__first, __last, __ITERATOR_CATEGORY(__first));
+  }
+
+#else
+  vector(const _Tp* __first, const _Tp* __last,
+         const allocator_type& __a = allocator_type())
+    : _Base(__last - __first, __a) 
+    { _M_finish = uninitialized_copy(__first, __last, _M_start); }
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  ~vector() { destroy(_M_start, _M_finish); }
+
+  vector<_Tp, _Alloc>& operator=(const vector<_Tp, _Alloc>& __x);
+  void reserve(size_type __n) {
+    if (capacity() < __n) {
+      const size_type __old_size = size();
+      iterator __tmp = _M_allocate_and_copy(__n, _M_start, _M_finish);
+      destroy(_M_start, _M_finish);
+      _M_deallocate(_M_start, _M_end_of_storage - _M_start);
+      _M_start = __tmp;
+      _M_finish = __tmp + __old_size;
+      _M_end_of_storage = _M_start + __n;
+    }
+  }
+
+  // assign(), a generalized assignment member function.  Two
+  // versions: one that takes a count, and one that takes a range.
+  // The range version is a member template, so we dispatch on whether
+  // or not the type is an integer.
+
+  void assign(size_type __n, const _Tp& __val);
+
+#ifdef __STL_MEMBER_TEMPLATES
+  
+  template <class _InputIterator>
+  void assign(_InputIterator __first, _InputIterator __last) {
+    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
+    _M_assign_dispatch(__first, __last, _Integral());
+  }
+
+  template <class _Integer>
+  void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+    { assign((size_type) __n, (_Tp) __val); }
+
+  template <class _InputIter>
+  void _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type)
+    { _M_assign_aux(__first, __last, __ITERATOR_CATEGORY(__first)); }
+
+  template <class _InputIterator>
+  void _M_assign_aux(_InputIterator __first, _InputIterator __last,
+                     input_iterator_tag);
+
+  template <class _ForwardIterator>
+  void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+                     forward_iterator_tag); 
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  reference front() { return *begin(); }
+  const_reference front() const { return *begin(); }
+  reference back() { return *(end() - 1); }
+  const_reference back() const { return *(end() - 1); }
+
+  void push_back(const _Tp& __x) {
+    if (_M_finish != _M_end_of_storage) {
+      construct(_M_finish, __x);
+      ++_M_finish;
+    }
+    else
+      _M_insert_aux(end(), __x);
+  }
+  void push_back() {
+    if (_M_finish != _M_end_of_storage) {
+      construct(_M_finish);
+      ++_M_finish;
+    }
+    else
+      _M_insert_aux(end());
+  }
+  void swap(vector<_Tp, _Alloc>& __x) {
+    __STD::swap(_M_start, __x._M_start);
+    __STD::swap(_M_finish, __x._M_finish);
+    __STD::swap(_M_end_of_storage, __x._M_end_of_storage);
+  }
+
+  iterator insert(iterator __position, const _Tp& __x) {
+    size_type __n = __position - begin();
+    if (_M_finish != _M_end_of_storage && __position == end()) {
+      construct(_M_finish, __x);
+      ++_M_finish;
+    }
+    else
+      _M_insert_aux(__position, __x);
+    return begin() + __n;
+  }
+  iterator insert(iterator __position) {
+    size_type __n = __position - begin();
+    if (_M_finish != _M_end_of_storage && __position == end()) {
+      construct(_M_finish);
+      ++_M_finish;
+    }
+    else
+      _M_insert_aux(__position);
+    return begin() + __n;
+  }
+#ifdef __STL_MEMBER_TEMPLATES
+  // Check whether it's an integral type.  If so, it's not an iterator.
+  template <class _InputIterator>
+  void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
+    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
+    _M_insert_dispatch(__pos, __first, __last, _Integral());
+  }
+
+  template <class _Integer>
+  void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
+                          __true_type) {
+    insert(__pos, (size_type) __n, (_Tp) __val);
+  }
+
+  template <class _InputIterator>
+  void _M_insert_dispatch(iterator __pos,
+                          _InputIterator __first, _InputIterator __last,
+                          __false_type) {
+    _M_range_insert(__pos, __first, __last, __ITERATOR_CATEGORY(__first));
+  }
+#else /* __STL_MEMBER_TEMPLATES */
+  void insert(iterator __position,
+              const_iterator __first, const_iterator __last);
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  void insert (iterator __pos, size_type __n, const _Tp& __x);
+
+  void pop_back() {
+    --_M_finish;
+    destroy(_M_finish);
+  }
+  iterator erase(iterator __position) {
+    if (__position + 1 != end())
+      copy(__position + 1, _M_finish, __position);
+    --_M_finish;
+    destroy(_M_finish);
+    return __position;
+  }
+  iterator erase(iterator __first, iterator __last) {
+    iterator __i = copy(__last, _M_finish, __first);
+    destroy(__i, _M_finish);
+    _M_finish = _M_finish - (__last - __first);
+    return __first;
+  }
+
+  void resize(size_type __new_size, const _Tp& __x) {
+    if (__new_size < size()) 
+      erase(begin() + __new_size, end());
+    else
+      insert(end(), __new_size - size(), __x);
+  }
+  void resize(size_type __new_size) { resize(__new_size, _Tp()); }
+  void clear() { erase(begin(), end()); }
+
+protected:
+
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _ForwardIterator>
+  iterator _M_allocate_and_copy(size_type __n, _ForwardIterator __first, 
+                                               _ForwardIterator __last)
+{
+    iterator __result = _M_allocate(__n);
+    __STL_TRY {
+      uninitialized_copy(__first, __last, __result);
+      return __result;
+    }
+    __STL_UNWIND(_M_deallocate(__result, __n));
+  }
+#else /* __STL_MEMBER_TEMPLATES */
+  iterator _M_allocate_and_copy(size_type __n, const_iterator __first, 
+                                               const_iterator __last)
+  {
+    iterator __result = _M_allocate(__n);
+    __STL_TRY {
+      uninitialized_copy(__first, __last, __result);
+      return __result;
+    }
+    __STL_UNWIND(_M_deallocate(__result, __n));
+  }
+#endif /* __STL_MEMBER_TEMPLATES */
+
+
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  void _M_range_initialize(_InputIterator __first,  
+                           _InputIterator __last, input_iterator_tag)
+  {
+    for ( ; __first != __last; ++__first)
+      push_back(*__first);
+  }
+
+  // This function is only called by the constructor. 
+  template <class _ForwardIterator>
+  void _M_range_initialize(_ForwardIterator __first,
+                           _ForwardIterator __last, forward_iterator_tag)
+  {
+    size_type __n = 0;
+    distance(__first, __last, __n);
+    _M_start = _M_allocate(__n);
+    _M_end_of_storage = _M_start + __n;
+    _M_finish = uninitialized_copy(__first, __last, _M_start);
+  }
+
+  template <class _InputIterator>
+  void _M_range_insert(iterator __pos,
+                       _InputIterator __first, _InputIterator __last,
+                       input_iterator_tag);
+
+  template <class _ForwardIterator>
+  void _M_range_insert(iterator __pos,
+                       _ForwardIterator __first, _ForwardIterator __last,
+                       forward_iterator_tag);
+
+#endif /* __STL_MEMBER_TEMPLATES */
+};
+
+template <class _Tp, class _Alloc>
+inline bool 
+operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+{
+  return __x.size() == __y.size() &&
+         equal(__x.begin(), __x.end(), __y.begin());
+}
+
+template <class _Tp, class _Alloc>
+inline bool 
+operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+{
+  return lexicographical_compare(__x.begin(), __x.end(), 
+                                 __y.begin(), __y.end());
+}
+
+#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
+
+template <class _Tp, class _Alloc>
+inline void swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
+{
+  __x.swap(__y);
+}
+
+#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
+
+template <class _Tp, class _Alloc>
+vector<_Tp,_Alloc>& 
+vector<_Tp,_Alloc>::operator=(const vector<_Tp, _Alloc>& __x)
+{
+  if (&__x != this) {
+    const size_type __xlen = __x.size();
+    if (__xlen > capacity()) {
+      iterator __tmp = _M_allocate_and_copy(__xlen, __x.begin(), __x.end());
+      destroy(_M_start, _M_finish);
+      _M_deallocate(_M_start, _M_end_of_storage - _M_start);
+      _M_start = __tmp;
+      _M_end_of_storage = _M_start + __xlen;
+    }
+    else if (size() >= __xlen) {
+      iterator __i = copy(__x.begin(), __x.end(), begin());
+      destroy(__i, _M_finish);
+    }
+    else {
+      copy(__x.begin(), __x.begin() + size(), _M_start);
+      uninitialized_copy(__x.begin() + size(), __x.end(), _M_finish);
+    }
+    _M_finish = _M_start + __xlen;
+  }
+  return *this;
+}
+
+template <class _Tp, class _Alloc>
+void vector<_Tp, _Alloc>::assign(size_t __n, const value_type& __val) {
+  if (__n > capacity()) {
+    vector<_Tp, _Alloc> __tmp(__n, __val, get_allocator());
+    __tmp.swap(*this);
+  }
+  else if (__n > size()) {
+    fill(begin(), end(), __val);
+    _M_finish = uninitialized_fill_n(_M_finish, __n - size(), __val);
+  }
+  else
+    erase(fill_n(begin(), __n, __val), end());
+}
+
+#ifdef __STL_MEMBER_TEMPLATES
+
+template <class _Tp, class _Alloc> template <class _InputIter>
+void vector<_Tp, _Alloc>::_M_assign_aux(_InputIter __first, _InputIter __last,
+                                        input_iterator_tag) {
+  iterator __cur = begin();
+  for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
+    *__cur = *__first;
+  if (__first == __last)
+    erase(__cur, end());
+  else
+    insert(end(), __first, __last);
+}
+
+template <class _Tp, class _Alloc> template <class _ForwardIter>
+void
+vector<_Tp, _Alloc>::_M_assign_aux(_ForwardIter __first, _ForwardIter __last,
+                                   forward_iterator_tag) {
+  size_type __len = 0;
+  distance(__first, __last, __len);
+
+  if (__len > capacity()) {
+    iterator __tmp = _M_allocate_and_copy(__len, __first, __last);
+    destroy(_M_start, _M_finish);
+    _M_deallocate(_M_start, _M_end_of_storage - _M_start);
+    _M_start = __tmp;
+    _M_end_of_storage = _M_finish = _M_start + __len;
+  }
+  else if (size() >= __len) {
+    iterator __new_finish = copy(__first, __last, _M_start);
+    destroy(__new_finish, _M_finish);
+    _M_finish = __new_finish;
+  }
+  else {
+    _ForwardIter __mid = __first;
+    advance(__mid, size());
+    copy(__first, __mid, _M_start);
+    _M_finish = uninitialized_copy(__mid, __last, _M_finish);
+  }
+}
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+template <class _Tp, class _Alloc>
+void 
+vector<_Tp, _Alloc>::_M_insert_aux(iterator __position, const _Tp& __x)
+{
+  if (_M_finish != _M_end_of_storage) {
+    construct(_M_finish, *(_M_finish - 1));
+    ++_M_finish;
+    _Tp __x_copy = __x;
+    copy_backward(__position, _M_finish - 2, _M_finish - 1);
+    *__position = __x_copy;
+  }
+  else {
+    const size_type __old_size = size();
+    const size_type __len = __old_size != 0 ? 2 * __old_size : 1;
+    iterator __new_start = _M_allocate(__len);
+    iterator __new_finish = __new_start;
+    __STL_TRY {
+      __new_finish = uninitialized_copy(_M_start, __position, __new_start);
+      construct(__new_finish, __x);
+      ++__new_finish;
+      __new_finish = uninitialized_copy(__position, _M_finish, __new_finish);
+    }
+    __STL_UNWIND((destroy(__new_start,__new_finish), 
+                  _M_deallocate(__new_start,__len)));
+    destroy(begin(), end());
+    _M_deallocate(_M_start, _M_end_of_storage - _M_start);
+    _M_start = __new_start;
+    _M_finish = __new_finish;
+    _M_end_of_storage = __new_start + __len;
+  }
+}
+
+template <class _Tp, class _Alloc>
+void 
+vector<_Tp, _Alloc>::_M_insert_aux(iterator __position)
+{
+  if (_M_finish != _M_end_of_storage) {
+    construct(_M_finish, *(_M_finish - 1));
+    ++_M_finish;
+    copy_backward(__position, _M_finish - 2, _M_finish - 1);
+    *__position = _Tp();
+  }
+  else {
+    const size_type __old_size = size();
+    const size_type __len = __old_size != 0 ? 2 * __old_size : 1;
+    iterator __new_start = _M_allocate(__len);
+    iterator __new_finish = __new_start;
+    __STL_TRY {
+      __new_finish = uninitialized_copy(_M_start, __position, __new_start);
+      construct(__new_finish);
+      ++__new_finish;
+      __new_finish = uninitialized_copy(__position, _M_finish, __new_finish);
+    }
+    __STL_UNWIND((destroy(__new_start,__new_finish), 
+                  _M_deallocate(__new_start,__len)));
+    destroy(begin(), end());
+    _M_deallocate(_M_start, _M_end_of_storage - _M_start);
+    _M_start = __new_start;
+    _M_finish = __new_finish;
+    _M_end_of_storage = __new_start + __len;
+  }
+}
+
+template <class _Tp, class _Alloc>
+void vector<_Tp, _Alloc>::insert(iterator __position, size_type __n, 
+                                 const _Tp& __x)
+{
+  if (__n != 0) {
+    if (size_type(_M_end_of_storage - _M_finish) >= __n) {
+      _Tp __x_copy = __x;
+      const size_type __elems_after = _M_finish - __position;
+      iterator __old_finish = _M_finish;
+      if (__elems_after > __n) {
+        uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);
+        _M_finish += __n;
+        copy_backward(__position, __old_finish - __n, __old_finish);
+        fill(__position, __position + __n, __x_copy);
+      }
+      else {
+        uninitialized_fill_n(_M_finish, __n - __elems_after, __x_copy);
+        _M_finish += __n - __elems_after;
+        uninitialized_copy(__position, __old_finish, _M_finish);
+        _M_finish += __elems_after;
+        fill(__position, __old_finish, __x_copy);
+      }
+    }
+    else {
+      const size_type __old_size = size();        
+      const size_type __len = __old_size + max(__old_size, __n);
+      iterator __new_start = _M_allocate(__len);
+      iterator __new_finish = __new_start;
+      __STL_TRY {
+        __new_finish = uninitialized_copy(_M_start, __position, __new_start);
+        __new_finish = uninitialized_fill_n(__new_finish, __n, __x);
+        __new_finish
+          = uninitialized_copy(__position, _M_finish, __new_finish);
+      }
+      __STL_UNWIND((destroy(__new_start,__new_finish), 
+                    _M_deallocate(__new_start,__len)));
+      destroy(_M_start, _M_finish);
+      _M_deallocate(_M_start, _M_end_of_storage - _M_start);
+      _M_start = __new_start;
+      _M_finish = __new_finish;
+      _M_end_of_storage = __new_start + __len;
+    }
+  }
+}
+
+#ifdef __STL_MEMBER_TEMPLATES
+
+template <class _Tp, class _Alloc> template <class _InputIterator>
+void 
+vector<_Tp, _Alloc>::_M_range_insert(iterator __pos, 
+                                     _InputIterator __first, 
+                                     _InputIterator __last,
+                                     input_iterator_tag)
+{
+  for ( ; __first != __last; ++__first) {
+    __pos = insert(__pos, *__first);
+    ++__pos;
+  }
+}
+
+template <class _Tp, class _Alloc> template <class _ForwardIterator>
+void 
+vector<_Tp, _Alloc>::_M_range_insert(iterator __position,
+                                     _ForwardIterator __first,
+                                     _ForwardIterator __last,
+                                     forward_iterator_tag)
+{
+  if (__first != __last) {
+    size_type __n = 0;
+    distance(__first, __last, __n);
+    if (size_type(_M_end_of_storage - _M_finish) >= __n) {
+      const size_type __elems_after = _M_finish - __position;
+      iterator __old_finish = _M_finish;
+      if (__elems_after > __n) {
+        uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);
+        _M_finish += __n;
+        copy_backward(__position, __old_finish - __n, __old_finish);
+        copy(__first, __last, __position);
+      }
+      else {
+        _ForwardIterator __mid = __first;
+        advance(__mid, __elems_after);
+        uninitialized_copy(__mid, __last, _M_finish);
+        _M_finish += __n - __elems_after;
+        uninitialized_copy(__position, __old_finish, _M_finish);
+        _M_finish += __elems_after;
+        copy(__first, __mid, __position);
+      }
+    }
+    else {
+      const size_type __old_size = size();
+      const size_type __len = __old_size + max(__old_size, __n);
+      iterator __new_start = _M_allocate(__len);
+      iterator __new_finish = __new_start;
+      __STL_TRY {
+        __new_finish = uninitialized_copy(_M_start, __position, __new_start);
+        __new_finish = uninitialized_copy(__first, __last, __new_finish);
+        __new_finish
+          = uninitialized_copy(__position, _M_finish, __new_finish);
+      }
+      __STL_UNWIND((destroy(__new_start,__new_finish), 
+                    _M_deallocate(__new_start,__len)));
+      destroy(_M_start, _M_finish);
+      _M_deallocate(_M_start, _M_end_of_storage - _M_start);
+      _M_start = __new_start;
+      _M_finish = __new_finish;
+      _M_end_of_storage = __new_start + __len;
+    }
+  }
+}
+
+#else /* __STL_MEMBER_TEMPLATES */
+
+template <class _Tp, class _Alloc>
+void 
+vector<_Tp, _Alloc>::insert(iterator __position, 
+                            const_iterator __first, 
+                            const_iterator __last)
+{
+  if (__first != __last) {
+    size_type __n = 0;
+    distance(__first, __last, __n);
+    if (size_type(_M_end_of_storage - _M_finish) >= __n) {
+      const size_type __elems_after = _M_finish - __position;
+      iterator __old_finish = _M_finish;
+      if (__elems_after > __n) {
+        uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);
+        _M_finish += __n;
+        copy_backward(__position, __old_finish - __n, __old_finish);
+        copy(__first, __last, __position);
+      }
+      else {
+        uninitialized_copy(__first + __elems_after, __last, _M_finish);
+        _M_finish += __n - __elems_after;
+        uninitialized_copy(__position, __old_finish, _M_finish);
+        _M_finish += __elems_after;
+        copy(__first, __first + __elems_after, __position);
+      }
+    }
+    else {
+      const size_type __old_size = size();
+      const size_type __len = __old_size + max(__old_size, __n);
+      iterator __new_start = _M_allocate(__len);
+      iterator __new_finish = __new_start;
+      __STL_TRY {
+        __new_finish = uninitialized_copy(_M_start, __position, __new_start);
+        __new_finish = uninitialized_copy(__first, __last, __new_finish);
+        __new_finish
+          = uninitialized_copy(__position, _M_finish, __new_finish);
+      }
+      __STL_UNWIND((destroy(__new_start,__new_finish),
+                    _M_deallocate(__new_start,__len)));
+      destroy(_M_start, _M_finish);
+      _M_deallocate(_M_start, _M_end_of_storage - _M_start);
+      _M_start = __new_start;
+      _M_finish = __new_finish;
+      _M_end_of_storage = __new_start + __len;
+    }
+  }
+}
+
+#endif /* __STL_MEMBER_TEMPLATES */
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1174
+#pragma reset woff 1375
+#endif
+
+__STL_END_NAMESPACE 
+
+#endif /* __SGI_STL_INTERNAL_VECTOR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/tempbuf.h b/gnu/egcs/libstdc++/stl/tempbuf.h
new file mode 100644
index 00000000000..aa4f289c582
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/tempbuf.h
@@ -0,0 +1,61 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_TEMPBUF_H
+#define __SGI_STL_TEMPBUF_H
+
+#ifndef __SGI_STL_PAIR_H
+#include <pair.h>
+#endif
+#include <limits.h>      /* XXX should use <climits> */
+#include <stddef.h>      /* XXX should use <cstddef> */
+#include <stdlib.h>      /* XXX should use <cstdlib> */
+#ifndef __TYPE_TRAITS_H
+#include <type_traits.h>
+#endif
+#ifndef __SGI_STL_INTERNAL_CONSTRUCT_H
+#include <stl_construct.h>
+#endif
+#ifndef __SGI_STL_INTERNAL_UNINITIALIZED_H
+#include <stl_uninitialized.h>
+#endif
+#ifndef __SGI_STL_INTERNAL_TEMPBUF_H
+#include <stl_tempbuf.h>
+#endif
+
+#ifdef __STL_USE_NAMESPACES
+
+using __STD::get_temporary_buffer;
+using __STD::return_temporary_buffer;
+using __STD::temporary_buffer;
+
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_TEMPBUF_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/tree.h b/gnu/egcs/libstdc++/stl/tree.h
new file mode 100644
index 00000000000..77c57cbbba1
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/tree.h
@@ -0,0 +1,46 @@
+/*
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ */
+
+#ifndef __SGI_STL_TREE_H
+#define __SGI_STL_TREE_H
+
+#ifndef __SGI_STL_INTERNAL_TREE_H
+#include <stl_tree.h>
+#endif
+#include <algobase.h>
+#include <alloc.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::rb_tree;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_TREE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/type_traits.h b/gnu/egcs/libstdc++/stl/type_traits.h
new file mode 100644
index 00000000000..b6a7dfc6de9
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/type_traits.h
@@ -0,0 +1,373 @@
+/*
+ *
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __TYPE_TRAITS_H
+#define __TYPE_TRAITS_H
+
+#ifndef __STL_CONFIG_H
+#include <stl_config.h>
+#endif
+
+/*
+This header file provides a framework for allowing compile time dispatch
+based on type attributes. This is useful when writing template code.
+For example, when making a copy of an array of an unknown type, it helps
+to know if the type has a trivial copy constructor or not, to help decide
+if a memcpy can be used.
+
+The class template __type_traits provides a series of typedefs each of
+which is either __true_type or __false_type. The argument to
+__type_traits can be any type. The typedefs within this template will
+attain their correct values by one of these means:
+    1. The general instantiation contain conservative values which work
+       for all types.
+    2. Specializations may be declared to make distinctions between types.
+    3. Some compilers (such as the Silicon Graphics N32 and N64 compilers)
+       will automatically provide the appropriate specializations for all
+       types.
+
+EXAMPLE:
+
+//Copy an array of elements which have non-trivial copy constructors
+template <class T> void copy(T* source, T* destination, int n, __false_type);
+//Copy an array of elements which have trivial copy constructors. Use memcpy.
+template <class T> void copy(T* source, T* destination, int n, __true_type);
+
+//Copy an array of any type by using the most efficient copy mechanism
+template <class T> inline void copy(T* source,T* destination,int n) {
+   copy(source, destination, n,
+        typename __type_traits<T>::has_trivial_copy_constructor());
+}
+*/
+
+
+struct __true_type {
+};
+
+struct __false_type {
+};
+
+template <class _Tp>
+struct __type_traits { 
+   typedef __true_type     this_dummy_member_must_be_first;
+                   /* Do not remove this member. It informs a compiler which
+                      automatically specializes __type_traits that this
+                      __type_traits template is special. It just makes sure that
+                      things work if an implementation is using a template
+                      called __type_traits for something unrelated. */
+
+   /* The following restrictions should be observed for the sake of
+      compilers which automatically produce type specific specializations 
+      of this class:
+          - You may reorder the members below if you wish
+          - You may remove any of the members below if you wish
+          - You must not rename members without making the corresponding
+            name change in the compiler
+          - Members you add will be treated like regular members unless
+            you add the appropriate support in the compiler. */
+ 
+
+   typedef __false_type    has_trivial_default_constructor;
+   typedef __false_type    has_trivial_copy_constructor;
+   typedef __false_type    has_trivial_assignment_operator;
+   typedef __false_type    has_trivial_destructor;
+   typedef __false_type    is_POD_type;
+};
+
+
+
+// Provide some specializations.  This is harmless for compilers that
+//  have built-in __types_traits support, and essential for compilers
+//  that don't.
+
+#ifndef __STL_NO_BOOL
+
+__STL_TEMPLATE_NULL struct __type_traits<bool> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+#endif /* __STL_NO_BOOL */
+
+__STL_TEMPLATE_NULL struct __type_traits<char> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+__STL_TEMPLATE_NULL struct __type_traits<signed char> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+__STL_TEMPLATE_NULL struct __type_traits<unsigned char> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+#ifdef __STL_HAS_WCHAR_T
+
+__STL_TEMPLATE_NULL struct __type_traits<wchar_t> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+#endif /* __STL_HAS_WCHAR_T */
+
+__STL_TEMPLATE_NULL struct __type_traits<short> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+__STL_TEMPLATE_NULL struct __type_traits<unsigned short> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+__STL_TEMPLATE_NULL struct __type_traits<int> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+__STL_TEMPLATE_NULL struct __type_traits<unsigned int> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+__STL_TEMPLATE_NULL struct __type_traits<long> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+__STL_TEMPLATE_NULL struct __type_traits<unsigned long> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+#ifdef __STL_LONG_LONG
+
+__STL_TEMPLATE_NULL struct __type_traits<long long> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+__STL_TEMPLATE_NULL struct __type_traits<unsigned long long> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+#endif /* __STL_LONG_LONG */
+
+__STL_TEMPLATE_NULL struct __type_traits<float> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+__STL_TEMPLATE_NULL struct __type_traits<double> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+__STL_TEMPLATE_NULL struct __type_traits<long double> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class _Tp>
+struct __type_traits<_Tp*> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+__STL_TEMPLATE_NULL struct __type_traits<char*> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+__STL_TEMPLATE_NULL struct __type_traits<signed char*> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+__STL_TEMPLATE_NULL struct __type_traits<unsigned char*> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+__STL_TEMPLATE_NULL struct __type_traits<const char*> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+__STL_TEMPLATE_NULL struct __type_traits<const signed char*> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+__STL_TEMPLATE_NULL struct __type_traits<const unsigned char*> {
+   typedef __true_type    has_trivial_default_constructor;
+   typedef __true_type    has_trivial_copy_constructor;
+   typedef __true_type    has_trivial_assignment_operator;
+   typedef __true_type    has_trivial_destructor;
+   typedef __true_type    is_POD_type;
+};
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+
+// The following could be written in terms of numeric_limits.  
+// We're doing it separately to reduce the number of dependencies.
+
+template <class _Tp> struct _Is_integer {
+  typedef __false_type _Integral;
+};
+
+#ifndef __STL_NO_BOOL
+
+__STL_TEMPLATE_NULL struct _Is_integer<bool> {
+  typedef __true_type _Integral;
+};
+
+#endif /* __STL_NO_BOOL */
+
+__STL_TEMPLATE_NULL struct _Is_integer<char> {
+  typedef __true_type _Integral;
+};
+
+__STL_TEMPLATE_NULL struct _Is_integer<signed char> {
+  typedef __true_type _Integral;
+};
+
+__STL_TEMPLATE_NULL struct _Is_integer<unsigned char> {
+  typedef __true_type _Integral;
+};
+
+#ifdef __STL_HAS_WCHAR_T
+
+__STL_TEMPLATE_NULL struct _Is_integer<wchar_t> {
+  typedef __true_type _Integral;
+};
+
+#endif /* __STL_HAS_WCHAR_T */
+
+__STL_TEMPLATE_NULL struct _Is_integer<short> {
+  typedef __true_type _Integral;
+};
+
+__STL_TEMPLATE_NULL struct _Is_integer<unsigned short> {
+  typedef __true_type _Integral;
+};
+
+__STL_TEMPLATE_NULL struct _Is_integer<int> {
+  typedef __true_type _Integral;
+};
+
+__STL_TEMPLATE_NULL struct _Is_integer<unsigned int> {
+  typedef __true_type _Integral;
+};
+
+__STL_TEMPLATE_NULL struct _Is_integer<long> {
+  typedef __true_type _Integral;
+};
+
+__STL_TEMPLATE_NULL struct _Is_integer<unsigned long> {
+  typedef __true_type _Integral;
+};
+
+#ifdef __STL_LONG_LONG
+
+__STL_TEMPLATE_NULL struct _Is_integer<long long> {
+  typedef __true_type _Integral;
+};
+
+__STL_TEMPLATE_NULL struct _Is_integer<unsigned long long> {
+  typedef __true_type _Integral;
+};
+
+#endif /* __STL_LONG_LONG */
+
+#endif /* __TYPE_TRAITS_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/utility b/gnu/egcs/libstdc++/stl/utility
new file mode 100644
index 00000000000..df8c224388d
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/utility
@@ -0,0 +1,38 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_UTILITY
+#define __SGI_STL_UTILITY
+
+#include <stl_config.h>
+#include <stl_relops.h>
+#include <stl_pair.h>
+
+#endif /* __SGI_STL_UTILITY */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/vector b/gnu/egcs/libstdc++/stl/vector
new file mode 100644
index 00000000000..4bcdebcc186
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/vector
@@ -0,0 +1,41 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_VECTOR
+#define __SGI_STL_VECTOR
+
+#include <stl_algobase.h>
+#include <stl_alloc.h>
+#include <stl_construct.h>
+#include <stl_uninitialized.h>
+#include <stl_vector.h>
+#include <stl_bvector.h>
+
+#endif /* __SGI_STL_VECTOR */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stl/vector.h b/gnu/egcs/libstdc++/stl/vector.h
new file mode 100644
index 00000000000..231a227b7e3
--- /dev/null
+++ b/gnu/egcs/libstdc++/stl/vector.h
@@ -0,0 +1,42 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_VECTOR_H
+#define __SGI_STL_VECTOR_H
+
+#include <algobase.h>
+#include <alloc.h>
+#include <stl_vector.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::vector;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* __SGI_STL_VECTOR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/gnu/egcs/libstdc++/stlinst.cc b/gnu/egcs/libstdc++/stlinst.cc
new file mode 100644
index 00000000000..2a221fbaee9
--- /dev/null
+++ b/gnu/egcs/libstdc++/stlinst.cc
@@ -0,0 +1,10 @@
+// Instantiation file for the -*- C++ -*- Standard Library allocator templates
+// This file is part of the GNU ANSI C++ Library.
+
+#include <alloc.h>
+
+#ifndef __USE_MALLOC
+template class __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0>;
+#endif
+
+template class  __malloc_alloc_template<0>;
diff --git a/gnu/egcs/libstdc++/string b/gnu/egcs/libstdc++/string
new file mode 100644
index 00000000000..fa6f1abaa70
--- /dev/null
+++ b/gnu/egcs/libstdc++/string
@@ -0,0 +1,13 @@
+// Main header for the -*- C++ -*- string classes.
+
+#ifndef __STRING__
+#define __STRING__
+
+#include <std/bastring.h>
+
+extern "C++" {
+typedef basic_string <char> string;
+// typedef basic_string <wchar_t> wstring;
+} // extern "C++"
+
+#endif
diff --git a/gnu/egcs/libstdc++/strstream b/gnu/egcs/libstdc++/strstream
new file mode 100644
index 00000000000..ee360e0b7e4
--- /dev/null
+++ b/gnu/egcs/libstdc++/strstream
@@ -0,0 +1,7 @@
+// -*- C++ -*- forwarding header.
+// This file is part of the GNU ANSI C++ Library.
+
+#ifndef __STRSTREAM__
+#define __STRSTREAM__
+#include <strstream.h>
+#endif
diff --git a/gnu/egcs/libstdc++/tests/ChangeLog b/gnu/egcs/libstdc++/tests/ChangeLog
new file mode 100644
index 00000000000..87ce0fc6c19
--- /dev/null
+++ b/gnu/egcs/libstdc++/tests/ChangeLog
@@ -0,0 +1,112 @@
+1998-07-17  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* tmap.cc: Use less<int>.
+	* tlist.cc (main): Use remove_if.
+
+1998-07-13  Manfred Hollstein  <manfred@s-direktnet.de>
+
+	* Makefile.in (VERSION): Bump to 2.9.0.
+
+1998-07-12  Bob Sidebotham <rns@fore.com>
+
+	* tstring.cc (findtest): New fn.
+
+1998-06-01  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* tlist.cc, tvector.cc, tmap.cc: Remove explicit instantiations.
+
+Fri Oct 10 00:40:31 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* tstring.cc (identitytest): s/remove/erase/.
+
+Thu Sep 25 19:48:22 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* tstring.cc: Add some tests for the member templates.
+
+Wed Jun 11 11:00:10 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* tmap.cc: Explicitly instantiate allocator classes.
+	* tvector.cc, tlist.cc: Likewise.
+
+Fri May 16 18:38:05 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* tcomplex.cc (main): If we're using short doubles, compensate for
+ 	roundoff in result of pow(a,b).
+
+Thu May  1 17:37:53 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* configure.in (CHECK): Add $(CXXFLAGS).
+	* Makefile.in (tcomplex): Add $(CXXFLAGS).
+
+Fri Apr 25 16:07:46 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* configure.in: Change "check" to "check-old". Add do-nothing
+	check target.
+
+Sun Nov  3 12:44:48 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* tstring.cc: Treat string literals as const.
+
+Tue Sep 24 18:00:20 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* tstring.cc, tcomplex.cc: Remove gratuitous uses of std/.
+
+Mon Jun 17 14:05:50 1996  Per Bothner  <bothner@deneb.cygnus.com>
+
+	* tlist.cc (test_splice):  New test.
+
+Fri Mar 22 16:08:36 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* Makefile.in (VERSION): 2.8.0.
+
+	* tlist.cc, tmap.cc, tvector.cc: Remove explicit instantiation
+ 	directive.
+
+Sat Nov 18 19:52:26 1995  Mike Stump  <mrs@cygnus.com>
+
+	* Makefile.in: Update version to 2.7.1.
+
+Tue May  9 19:36:54 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* tstring.cc (decltest): Adjust single-character test.
+
+Fri May  5 14:35:19 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* tcomplex.*: Update to reflect that operator<< now
+        accepts more forms of input.
+
+Thu Apr 27 15:34:58 1995  Brendan Kehoe  (brendan@lisa.cygnus.com)
+
+	* configure.in: Update to stay in sync with config.shared.
+
+Thu Feb 16 00:08:28 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* Makefile.in (VERSION, SHLIB): Define.
+
+Tue Jan 24 02:36:24 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* Makefile.in (CXXFLAGS): Don't set.
+
+Mon Jan 23 04:12:10 1995  Jason Merrill  <jason@python.cygnus.com>
+
+	* tlist.cc (plus): Remove.
+
+Thu Jan 19 19:41:07 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* Makefile.in: Don't set LD_LIBRARY_PATH.  Users will have to set
+        it themselves.
+
+Mon Jan 16 13:57:34 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* Makefile.in: Update to reflect header movement.
+
+Wed Dec 14 19:55:45 1994  Per Bothner  <bothner@kalessin.cygnus.com>
+
+	* configure.in:  Fix quoting problem.  Reported nu H.J.Lu.
+
+Tue Nov 29 16:46:56 1994  Per Bothner  <bothner@kalessin.cygnus.com>
+
+	* Makefile.in, configure.in:  Re-write to avoid duplication.
+	* {tvector,tmap,tlist}.{cc,exp}, configure.in:  New tests for STL.
+
+
diff --git a/gnu/egcs/libstdc++/tests/Makefile.in b/gnu/egcs/libstdc++/tests/Makefile.in
new file mode 100644
index 00000000000..057482f185e
--- /dev/null
+++ b/gnu/egcs/libstdc++/tests/Makefile.in
@@ -0,0 +1,35 @@
+# Copyright (C) 1994 Free Software Foundation
+
+# This file is part of the GNU ANSI 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, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+VERSION = 2.9.0
+SHLIB   = libstdc++.so.$(VERSION)
+
+DEPLIBS  = ../libstdc++.a
+LDLIBS   = -L.. -lstdc++
+MDEPLIBS = $(DEPLIBS)
+MLDLIBS  = $(LDLIBS) -lm
+
+#### package, host, target, and site dependent Makefile fragments come in here.
+##
+
+tcomplex.o: ${srcdir}/../std/complext.h ${srcdir}/../std/dcomplex.h
+tcomplex: tcomplex.o $(MDEPLIBS)
+	$(CXX) $(CXXFLAGS) -o tcomplex tcomplex.o $(MLDLIBS)
+
+tstring.o: ${srcdir}/../std/bastring.h
+
+# NOTE: Rules for following tests are generated by $(srcdir)/configure.in !!!
+
diff --git a/gnu/egcs/libstdc++/tests/configure.in b/gnu/egcs/libstdc++/tests/configure.in
new file mode 100644
index 00000000000..06c56192beb
--- /dev/null
+++ b/gnu/egcs/libstdc++/tests/configure.in
@@ -0,0 +1,65 @@
+# This file is a shell script fragment that supplies the information
+# necessary for a configure script to process the program in
+# this directory.  For more information, look at ../../configure.
+
+configdirs=
+srctrigger=tcomplex.cc
+srcname="tests for ANSI C++ library"
+package_makefile_frag=Make.pack
+package_makefile_rules_frag=Make.pack.r
+
+# per-host:
+
+# per-target:
+
+target_makefile_frag=../target-mkfrag
+
+TO_TOPDIR=../../
+ALL=' '
+XCXXINCLUDES="-I${srcdir}/.. -I${srcdir}/../stl -I${TO_TOPDIR}libio -I${srcdir}/${TO_TOPDIR}libio"
+SIMPLE_TESTS='tstring tlist tmap tvector'
+TESTS="tcomplex ${SIMPLE_TESTS}"
+MOSTLYCLEAN="*.o core ${TESTS} *.out"
+(. ${srcdir}/${TO_TOPDIR}libio/config.shared) >${package_makefile_frag} 2>${package_makefile_rules_frag}
+
+# post-target:
+
+CHECK=""
+
+for TEST in ${SIMPLE_TESTS} ; do
+  echo "${TEST}: ${TEST}.o" '$(DEPLIBS)
+	$(CXX) $(CXXFLAGS) -o' "${TEST} ${TEST}.o" '$(LDLIBS)
+' >> Makefile
+done
+
+for TEST in ${TESTS} ; do
+  echo ".PHONY: check-${TEST}" >>Makefile
+  if [ -f ${srcdir}/${TEST}.inp ] ; then
+    echo "check-${TEST}: ${TEST}" '$(srcdir)'"/${TEST}.inp
+	./${TEST} < "'$(srcdir)'"/${TEST}.inp > ${TEST}.out 2>&1" >>Makefile
+  else
+    echo "check-${TEST}: ${TEST}
+	./${TEST} > ${TEST}.out 2>&1"  >>Makefile
+  fi
+  echo '	diff -c $(srcdir)/'"${TEST}.exp ${TEST}.out"  >>Makefile
+  CHECK="${CHECK} check-${TEST}"
+done
+
+if [ "${srcdir}" = "." ] ; then
+  if [ "${with_target_subdir}" != "." ] ; then
+    topsrcdir=${with_multisrctop}../../..
+  else
+    topsrcdir=${with_multisrctop}../..
+  fi
+else
+  topsrcdir=${srcdir}/../..
+fi
+
+if [ -d ${topsrcdir}/gcc ] ; then
+  echo "
+check:
+check-old: ${CHECK}" >>Makefile
+else
+  echo "
+check: ${CHECK}" >>Makefile
+fi
diff --git a/gnu/egcs/libstdc++/tests/tcomplex.cc b/gnu/egcs/libstdc++/tests/tcomplex.cc
new file mode 100644
index 00000000000..5311f0d8b7a
--- /dev/null
+++ b/gnu/egcs/libstdc++/tests/tcomplex.cc
@@ -0,0 +1,151 @@
+// Tests for the -*- C++ -*- complex number classes.
+// Copyright (C) 1994 Free Software Foundation
+
+// This file is part of the GNU ANSI 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, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include <assert.h>
+#include <iostream.h>
+#include <complex>
+
+// to test near-equality
+
+const double eps = 0.000001;
+
+static void close_enough(const double_complex& a, const double_complex& b)
+{
+  assert(fabs(real(a) - real(b)) < eps &&
+         fabs(imag(a) - imag(b)) < eps);
+}
+
+
+void test3(double_complex& a, double_complex& b, double_complex& c)
+{
+
+  close_enough(-(-a) , a);
+  close_enough((a + b) ,  (b + a));
+  close_enough((a + (-b)) ,  (a - b));
+  close_enough((a * b) ,  (b * a));
+  close_enough((a * (-b)) , -(a * b));
+  close_enough((a / (-b)) , -(a / b));
+  close_enough((a - b) ,  -(b - a));
+  close_enough((a + (b + c)) , ((a + b) + c));
+  close_enough((a * (b * c)) , ((a * b) * c));
+  close_enough((a * (b + c)) , ((a * b) + (a * c)));
+  close_enough(((a - b) + b) , a);
+  close_enough(((a + b) - b) , a);
+  close_enough(((a * b) / b) , a);
+  close_enough(((a / b) * b) , a);
+
+
+  double_complex x = a;
+  x *= b;
+  close_enough(x , (a * b));
+  x += c;
+  close_enough(x , ((a * b) + c));
+  x -= a;
+  close_enough(x , (((a * b) + c) - a));
+  x /= b;
+  close_enough(x , ((((a * b) + c) - a) / b));
+
+}
+
+main()
+{
+  double_complex one = 1.0;
+  double_complex i (0.0, 1.0);
+  double_complex neg_one = -1.0;
+
+  cout << "double_complex one = " << one << "\n";
+  cout << "i = " << i << "\n";
+  cout << "neg_one = " << neg_one << "\n";
+  cout << "sqrt(neg_one) = " << sqrt(neg_one) << "\n";
+
+  double_complex a (2.0, 3.0);
+  double_complex b (4.0, 5.0);
+
+  cout << "a = " << a << "\n";
+  cout << "b = " << b << "\n";
+
+  cout << "a + one = " << (a + one) << "\n";
+  (close_enough((a+one), double_complex(3.0, 3.0)));
+  cout << "a - one = " << (a - one) << "\n";
+  (close_enough((a-one), double_complex(1.0, 3.0)));
+  cout << "a * one = " << (a * one) << "\n";
+  (close_enough((a*one), a));
+  cout << "a / one = " << (a / one) << "\n";
+  (close_enough((a/one), a));
+
+  cout << "a + b = " << (a + b) << "\n";
+  (close_enough((a+b), double_complex(6.0, 8.0)));
+  cout << "a - b = " << (a - b) << "\n";
+  (close_enough((a-b), double_complex(-2.0, -2.0)));
+  cout << "a * b = " << (a * b) << "\n";
+  (close_enough((a*b), double_complex(-7.0, 22.0)));
+  cout << "a / b = " << (a / b) << "\n";
+  (close_enough((a/b), double_complex(0.5609760976, 0.0487804878)));
+
+  double_complex c;
+
+  c = a; cout << "c = a; c += b = " << (c += b) << "\n";
+  c = a; cout << "c = a; c -= b = " << (c -= b) << "\n";
+  c = a; cout << "c = a; c *= b = " << (c *= b) << "\n";
+  c = a; cout << "c = a; c /= b = " << (c /= b) << "\n";
+
+  cout << "-a = " << (-a) << "\n";
+  cout << "real(a) = " << real(a) << "\n";
+  assert(real(a) == 2.0);
+  cout << "imag(a) = " << imag(a) << "\n";
+  assert(imag(a) == 3.0);
+  cout << "conj(a) = " << conj(a) << "\n";
+  assert(conj(a) == double_complex(2.0, -3.0));
+  cout << "norm(a) = " << norm(a) << "\n";
+  assert(norm(a) == 13.0);
+
+  cout << "abs(a) = " << abs(a) << "\n";
+  cout << "arg(a) = " << arg(a) << "\n";
+  cout << "cos(a) = " << cos(a) << "\n";
+  cout << "sin(a) = " << sin(a) << "\n";
+  cout << "cosh(a) = " << cosh(a) << "\n";
+  cout << "sinh(a) = " << sinh(a) << "\n";
+  cout << "log(a) = " << log(a) << "\n";
+  cout << "exp(a) = " << exp(a) << "\n";
+  cout << "sqrt(a) = " << sqrt(a) << "\n";
+  cout << "pow(a, 2) = " << pow(a, 2) << "\n";
+  {
+     double_complex p = pow(a, b);
+     if(sizeof(float)==sizeof(double)) {
+	long w = (long)(p.imag()*100000);
+	if (w==-98642)
+	   p=double_complex(-0.753046,-0.986429);
+     }
+     cout << "pow(a, b) = " << p << "\n";
+  }
+
+  double_complex d (10, 20);
+  double_complex e = pow(a, 2);
+ 
+  test3(one, one, one);
+  test3(a, a, a);
+  test3(a, b, d);
+  test3(e, i, b);
+  test3(d, d, i);
+
+  cout << "enter a complex number in form a or (a) or (a, b): ";
+  cin >> c;
+  cout << "number = " << c << "\n";
+
+  cout << "\nEnd of test\n";
+  return 0;
+}
diff --git a/gnu/egcs/libstdc++/tests/tcomplex.exp b/gnu/egcs/libstdc++/tests/tcomplex.exp
new file mode 100644
index 00000000000..5bef15cd376
--- /dev/null
+++ b/gnu/egcs/libstdc++/tests/tcomplex.exp
@@ -0,0 +1,37 @@
+double_complex one = (1,0)
+i = (0,1)
+neg_one = (-1,0)
+sqrt(neg_one) = (0,1)
+a = (2,3)
+b = (4,5)
+a + one = (3,3)
+a - one = (1,3)
+a * one = (2,3)
+a / one = (2,3)
+a + b = (6,8)
+a - b = (-2,-2)
+a * b = (-7,22)
+a / b = (0.560976,0.0487805)
+c = a; c += b = (6,8)
+c = a; c -= b = (-2,-2)
+c = a; c *= b = (-7,22)
+c = a; c /= b = (0.560976,0.0487805)
+-a = (-2,-3)
+real(a) = 2
+imag(a) = 3
+conj(a) = (2,-3)
+norm(a) = 13
+abs(a) = 3.60555
+arg(a) = 0.982794
+cos(a) = (-4.18963,-9.10923)
+sin(a) = (9.1545,-4.16891)
+cosh(a) = (-3.72455,0.511823)
+sinh(a) = (-3.59056,0.530921)
+log(a) = (1.28247,0.982794)
+exp(a) = (-7.31511,1.04274)
+sqrt(a) = (1.67415,0.895977)
+pow(a, 2) = (-5,12)
+pow(a, b) = (-0.753046,-0.986429)
+enter a complex number in form a or (a) or (a, b): number = (1.2,-34)
+
+End of test
diff --git a/gnu/egcs/libstdc++/tests/tcomplex.inp b/gnu/egcs/libstdc++/tests/tcomplex.inp
new file mode 100644
index 00000000000..c4e1d84660f
--- /dev/null
+++ b/gnu/egcs/libstdc++/tests/tcomplex.inp
@@ -0,0 +1 @@
+(1.2, -34)
diff --git a/gnu/egcs/libstdc++/tests/tlist.cc b/gnu/egcs/libstdc++/tests/tlist.cc
new file mode 100644
index 00000000000..a37c999d0b5
--- /dev/null
+++ b/gnu/egcs/libstdc++/tests/tlist.cc
@@ -0,0 +1,151 @@
+// test/demo of generic lists
+
+#include <assert.h>
+
+#define tassert(ex) {if ((ex)) cerr << #ex << "\n"; \
+                       else _assert(#ex, __FILE__,__LINE__); }
+
+#include <iostream.h>
+#include <list.h>
+#include <algo.h>
+
+bool int_compare(int a, int b)
+{
+  return a < b;
+}
+
+int inc(int x)
+{
+  return x + 1;
+}
+
+void print(list<int>& l)
+{
+  for (list<int>::iterator it = l.begin(); it != l.end(); it++)
+    cout << *it << " ";
+  cout << "\n";
+}
+
+int is_odd(int x)
+{
+  return x & 1;
+}
+
+int is_even(int x)
+{
+  return (x & 1) == 0;
+}
+
+void sequence(list<int>& a, int lo, int hi)
+{
+  back_insert_iterator<list<int> > it(a);
+  while (lo <= hi)
+    *it++ = lo++;
+}
+
+int old_rand = 9999;
+
+int get_rand()
+{
+    old_rand = ((long)old_rand * (long)1243) % (long)971;
+    return old_rand;
+}
+
+void randseq(list<int>& a, int n)
+{
+  back_insert_iterator<list<int> > it(a);
+  while (--n >= 0)
+    *it++ = get_rand() % 50;
+}
+
+int array1 [] = { 9, 16, 36 };
+int array2 [] = { 1, 4 };
+
+int test_splice ()
+{
+  list<int> l1 (array1, array1 + 3);
+  list<int> l2 (array2, array2 + 2);
+  list<int>::iterator i1 = l1.begin ();
+  l1.splice (i1, l2);
+  list<int>::iterator i2 = l1.begin ();
+  while (i2 != l1.end ())
+    cout << *i2++ << endl;
+  return 0;
+}
+
+main()
+{
+  list<int> a;  int i;
+  list<int>::iterator it, bit;
+  sequence(a, 1, 20);
+  cout << "\nlist<int> a = sequence(1, 20);\n"; print(a);
+  for (it = a.begin (), i = 0; it != a.end (); it++, i++)
+    assert (*it == i + 1);
+  list<int> b;
+  randseq(b, 20);
+  cout << "\nlist<int> b = randseq(20);\n"; print(b);
+  list<int> c;
+  c.insert (c.end(), a.begin(), a.end());
+  c.insert (c.end(), b.begin(), b.end());
+  cout << "\nlist<int> c = a and b;\n"; print(c);
+
+  list<int> d;
+  for (it = a.begin(); it != a.end(); it++)
+    d.insert(d.end (), inc(*it));
+  cout << "\nlist<int> d = map(inc, a);\n"; print(d);
+
+  list<int> e;
+  back_insert_iterator<list<int> > e_insertor (e);
+  reverse_copy (a.begin(), a.end (), e_insertor);
+  cout << "\nlist<int> e = reverse(a);\n"; print(e);
+
+  list<int> f;
+  for (it = a.begin(); it != a.end(); it++)
+    if (is_odd (*it))
+      f.insert(f.end (), *it);
+  cout << "\nlist<int> f = select(is_odd, a);\n"; print(f);
+  list<int> ff;
+  for (it = f.begin(); it != f.end(); it++)
+    if (is_even (*it))
+      ff.insert(ff.end (), *it);
+  assert(ff.empty());
+
+  int red = 0;
+  for (it = a.begin(); it != a.end(); it++)
+    red += *it;
+  cout << "\nint  red = a.reduce(plus, 0);\n"; cout << red;
+  it = a.begin(); ++it; ++it;
+  int second = *it;
+  cout << "\nint second = a[2];\n"; cout << second;
+  list<int> g;
+  for (it = a.begin(), bit = b.begin(); it != a.end () && bit != b.end (); )
+    g.insert (g.end (), *it++ + *bit++);
+  cout << "\nlist<int> g = combine(plus, a, b);\n"; print(g);
+  g.remove_if (is_odd);
+  cout << "\ng.del(is_odd);\n"; print(g);
+
+  ff.erase (ff.begin (), ff.end());
+  for (it = g.begin(); it != g.end(); it++)
+    if (is_odd (*it))
+      ff.insert (ff.end (), *it);
+  assert(ff.empty());
+
+  b.sort();
+  for (it = b.begin(); bit = it++, it != b.end (); ) assert (*it >= *bit);
+  cout << "\nb.sort(int_compare);\n"; print(b);
+
+  list<int> h;
+  back_insert_iterator<list<int> > h_insertor (h);
+  merge (a.begin (), a.end (), b.begin (), b.end (), h_insertor, int_compare);
+  cout << "\nlist<int> h = merge(a, b, int_compare);\n"; print(h);
+  for (it = h.begin(); bit = it++, it != h.end (); ) assert (*it >= *bit);
+
+  cout << "\nh via iterator:\n";
+  for (it = h.begin(); it != h.end (); it++)
+    cout << *it << ", ";
+  cout << "\n";
+
+  test_splice ();
+
+  cout << "\ndone\n";
+}
diff --git a/gnu/egcs/libstdc++/tests/tlist.exp b/gnu/egcs/libstdc++/tests/tlist.exp
new file mode 100644
index 00000000000..65f7806826f
--- /dev/null
+++ b/gnu/egcs/libstdc++/tests/tlist.exp
@@ -0,0 +1,44 @@
+
+list<int> a = sequence(1, 20);
+1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 
+
+list<int> b = randseq(20);
+28 27 5 17 44 6 9 40 15 26 49 35 15 48 13 27 25 25 9 6 
+
+list<int> c = a and b;
+1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 28 27 5 17 44 6 9 40 15 26 49 35 15 48 13 27 25 25 9 6 
+
+list<int> d = map(inc, a);
+2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 
+
+list<int> e = reverse(a);
+20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 
+
+list<int> f = select(is_odd, a);
+1 3 5 7 9 11 13 15 17 19 
+
+int  red = a.reduce(plus, 0);
+210
+int second = a[2];
+3
+list<int> g = combine(plus, a, b);
+29 29 8 21 49 12 16 48 24 36 60 47 28 62 28 43 42 43 28 26 
+
+g.del(is_odd);
+8 12 16 48 24 36 60 28 62 28 42 28 26 
+
+b.sort(int_compare);
+5 6 6 9 9 13 15 15 17 25 25 26 27 27 28 35 40 44 48 49 
+
+list<int> h = merge(a, b, int_compare);
+1 2 3 4 5 5 6 6 6 7 8 9 9 9 10 11 12 13 13 14 15 15 15 16 17 17 18 19 20 25 25 26 27 27 28 35 40 44 48 49 
+
+h via iterator:
+1, 2, 3, 4, 5, 5, 6, 6, 6, 7, 8, 9, 9, 9, 10, 11, 12, 13, 13, 14, 15, 15, 15, 16, 17, 17, 18, 19, 20, 25, 25, 26, 27, 27, 28, 35, 40, 44, 48, 49, 
+1
+4
+9
+16
+36
+
+done
diff --git a/gnu/egcs/libstdc++/tests/tmap.cc b/gnu/egcs/libstdc++/tests/tmap.cc
new file mode 100644
index 00000000000..900e66f506b
--- /dev/null
+++ b/gnu/egcs/libstdc++/tests/tmap.cc
@@ -0,0 +1,59 @@
+#include <map.h>
+#include <algo.h>
+#include <iostream.h>
+#include <function.h>
+
+#define int_less less<int>
+struct str_less {
+  bool operator() (char* x, char* y) const { return strcmp(x,y) < 0; }
+};
+
+#if 0
+int SIZE;
+
+void add(int x[], int y[], map<int,int, int_less>& a)
+{
+  for (int i = 0; i < SIZE; ++i) a[x[i]] = y[i];
+}
+#endif
+
+int
+main(int argv, char** argc)
+{
+#if 0
+  if (argv > 1)
+  {
+    SIZE = abs(atoi(argc[1]));
+    SIZE &= ~1;
+  }
+  else
+    SIZE = 100;
+  nums = new int[SIZE];
+  odds = new int[SIZE];
+  perm = new int[SIZE];
+#endif
+
+  map<int, int, int_less> my_map;
+
+  map<char*, int, str_less> phones;
+
+  my_map[4] = 40;
+  my_map[2] = 20;
+
+  // The (char*) is needed because g++ doesn't
+  // convert char[] to char* in this context.
+  phones[(char*)"tom"] = 2345;
+  phones[(char*)"dick"] = 5678;
+  phones[(char*)"harry"] = 7654;
+
+  cout << "2 -> " << my_map[2] << endl;
+  cout << "4 -> " << my_map[4] << endl;
+
+  map<int, int, int_less>::iterator it = my_map.begin();
+  for ( ; it != my_map.end(); it++)
+    cout << "my_map[" << (*it).first << "] = " << (*it).second << endl; 
+
+  map<char*, int, str_less>::iterator pit = phones.begin();
+  for ( ; pit != phones.end(); pit++)
+    cout << "phones[" << (*pit).first << "] = " << (*pit).second << endl; 
+}
diff --git a/gnu/egcs/libstdc++/tests/tmap.exp b/gnu/egcs/libstdc++/tests/tmap.exp
new file mode 100644
index 00000000000..b7b5df249fb
--- /dev/null
+++ b/gnu/egcs/libstdc++/tests/tmap.exp
@@ -0,0 +1,7 @@
+2 -> 20
+4 -> 40
+my_map[2] = 20
+my_map[4] = 40
+phones[dick] = 5678
+phones[harry] = 7654
+phones[tom] = 2345
diff --git a/gnu/egcs/libstdc++/tests/tstring.cc b/gnu/egcs/libstdc++/tests/tstring.cc
new file mode 100644
index 00000000000..833d3d96460
--- /dev/null
+++ b/gnu/egcs/libstdc++/tests/tstring.cc
@@ -0,0 +1,249 @@
+// Tests for the -*- C++ -*- string classes.
+// Copyright (C) 1994 Free Software Foundation
+
+// This file is part of the GNU ANSI 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, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include <string>
+#include <algorithm>
+#include <iostream.h>
+#include <stdlib.h>
+#include <assert.h>
+
+string X = "Hello";
+string Y = "world";
+string N = "123";
+string c;
+const char*  s = ",";
+
+void decltest()
+{
+  string x;
+  cout << "an empty string:" << x << "\n";
+  assert(x == "");
+
+  string y = "Hello";
+  cout << "A string initialized to Hello:" << y << "\n";
+  assert(y == "Hello");
+
+  if (y[y.length()-1] == 'o')
+	y = y + '\n';
+  assert(y == "Hello\n");
+  y = "Hello";
+
+  string a = y;
+  cout << "A string initialized to previous string:" << a << "\n";
+  assert(a == "Hello");
+  assert(a == y);
+
+  string b (a, 1, 2);
+  cout << "A string initialized to (previous string, 1, 2):" << b << "\n";
+  assert(b == "el");
+
+  char ch = '@';
+  string z (1, ch);
+  cout << "A string initialized to @:" << z << "\n";
+  assert (z == "@");
+
+  string n ("20");
+  cout << "A string initialized to 20:" << n << "\n";
+  assert(n == "20");
+
+  int i = atoi(n.c_str ());
+  double f = atof(n.c_str ());
+  cout << "n = " << n << " atoi(n) = " << i << " atof(n) = " << f << "\n";
+  assert(i == 20);
+  assert(f == 20);
+
+  int ar[] = { 'H', 'e', 'l', 'l', 'o' };
+  string is (ar, ar+sizeof(ar)/sizeof(ar[0]));
+  cout << "is = " << is << endl;
+  assert (is == "Hello");
+}
+
+void cattest()
+{
+  string x = X;
+  string y = Y;
+  string z = x + y;
+  cout << "z = x + y = " << z << "\n";
+  assert(z == "Helloworld");
+
+  x += y;
+  cout << "x += y; x = " << x << "\n";
+  assert(x == "Helloworld");
+
+  y = Y;
+  x = X;
+  y.insert (0, x);
+  cout << "y.insert (0, x); y = " << y << "\n";
+  assert(y == "Helloworld");
+
+  y = Y;
+  x = X;
+  x = x + y + x;
+  cout << "x = x + y + x; x = " << x << "\n";
+  assert(x == "HelloworldHello");
+
+  y = Y;
+  x = X;
+  x = y + x + x;
+  cout << "x = y + x + x; x = " << x << "\n";
+  assert(x == "worldHelloHello");
+
+  x = X;
+  y = Y;
+  z = x + s + ' ' + y.substr (y.find ('w'), 1) + y.substr (y.find ('w') + 1) + ".";
+  cout << "z = x + s +  + y.substr (y.find (w), 1) + y.substr (y.find (w) + 1) + . = " << z << "\n";
+  assert(z == "Hello, world.");
+}
+
+void
+findtest()
+{
+  string x;
+  string::size_type pos;
+  pos = x.find_last_not_of('X');
+  assert(pos == string::npos);
+  pos = x.find_last_not_of("XYZ");
+  assert(pos == string::npos);
+
+  string y("a");
+  pos = y.find_last_not_of('X');
+  assert(pos == 0);
+  pos = y.find_last_not_of('a');
+  assert(pos == string::npos);
+  pos = y.find_last_not_of("XYZ");
+  assert(pos == 0);
+  pos = y.find_last_not_of("a");
+  assert(pos == string::npos);
+
+  string z("ab");
+  pos = z.find_last_not_of('X');
+  assert(pos == 1);
+  pos = z.find_last_not_of("XYZ");
+  assert(pos == 1);
+  pos = z.find_last_not_of('b');
+  assert(pos == 0);
+  pos = z.find_last_not_of("Xb");
+  assert(pos == 0);
+  pos = z.find_last_not_of("Xa");
+  assert(pos == 1);
+  pos = z.find_last_of("ab");
+  assert(pos == 1);
+  pos = z.find_last_of("Xa");
+  assert(pos == 0);
+  pos = z.find_last_of("Xb");
+  assert(pos == 1);
+  pos = z.find_last_of("XYZ");
+  assert(pos == string::npos);
+  pos = z.find_last_of('a');
+  assert(pos == 0);
+  pos = z.find_last_of('b');
+  assert(pos == 1);
+  pos = z.find_last_of('X');
+  assert(pos == string::npos);
+}
+
+void comparetest()
+{  
+  string x = X;
+  string y = Y;
+  string n = N;
+  string z = x + y;
+
+  assert(x != y);
+  assert(x == "Hello");
+  assert(x != z.substr (0, 4));
+  assert(x.compare (y) < 0);
+  assert(x.compare (z.substr (0, 6)) < 0);
+
+  assert(x.find ("lo") == 3);
+  assert(x.find ("l", 2) == 2);
+  assert(x.rfind ("l") == 3);
+}
+
+void substrtest()
+{
+  string x = X;
+
+  char ch = x[0];
+  cout << "ch = x[0] = " << ch << "\n";
+  assert(ch == 'H');
+
+  string z = x.substr (2, 3);
+  cout << "z = x.substr (2, 3) = " << z << "\n";
+  assert(z == "llo");
+
+  x.replace (2, 2, "r");
+  cout << "x.replace (2, 2, r); x = " << x << "\n";
+  assert(x == "Hero");
+
+  x = X;
+  x.replace (0, 1, 'j');
+  cout << "x.replace (0, 1, 'j'); x = " << x << "\n";
+  assert(x == "jello");
+
+  int ar[] = { 'H', 'e', 'l', 'l', 'o' };
+  x.replace (find (x.begin (), x.end (), 'l'),
+	     find (x.rbegin (), x.rend (), 'l').base (),
+	     ar, ar+sizeof(ar)/sizeof(ar[0]));
+  cout << "x = " << x << endl;
+  assert (x == "jeHelloo");
+}
+
+void iotest()
+{
+  string z;
+  cout << "enter a word:";
+  cin >> z;
+  cout << "word =" << z << " ";
+  cout << "length = " << z.length() << "\n";
+}
+
+void identitytest(string a, string b)
+{
+  string x = a;
+  string y = b;
+  x += b;
+  y.insert (0, a);
+  assert((a + b) == x);
+  assert((a + b) == y);
+  assert(x == y);
+  
+  assert((a + b + a) == (a + (b + a)));
+
+  x.erase (x.rfind (b));
+  assert(x == a);
+
+  y.replace (0, y.rfind (b), b);
+  assert(y == (b + b));
+  y.replace (y.find (b), b.length (), a);
+  assert(y == (a + b));
+}
+
+int main()
+{
+  decltest();
+  cattest();
+  comparetest();
+  findtest();
+  substrtest();
+  identitytest(X, X);
+  identitytest(X, Y);
+  identitytest(X+Y+N+X+Y+N, "A string that will be used in identitytest but is otherwise just another useless string.");
+  iotest();
+  cout << "\nEnd of test\n";
+  return 0;
+}
diff --git a/gnu/egcs/libstdc++/tests/tstring.exp b/gnu/egcs/libstdc++/tests/tstring.exp
new file mode 100644
index 00000000000..4526279b888
--- /dev/null
+++ b/gnu/egcs/libstdc++/tests/tstring.exp
@@ -0,0 +1,22 @@
+an empty string:
+A string initialized to Hello:Hello
+A string initialized to previous string:Hello
+A string initialized to (previous string, 1, 2):el
+A string initialized to @:@
+A string initialized to 20:20
+n = 20 atoi(n) = 20 atof(n) = 20
+is = Hello
+z = x + y = Helloworld
+x += y; x = Helloworld
+y.insert (0, x); y = Helloworld
+x = x + y + x; x = HelloworldHello
+x = y + x + x; x = worldHelloHello
+z = x + s +  + y.substr (y.find (w), 1) + y.substr (y.find (w) + 1) + . = Hello, world.
+ch = x[0] = H
+z = x.substr (2, 3) = llo
+x.replace (2, 2, r); x = Hero
+x.replace (0, 1, 'j'); x = jello
+x = jeHelloo
+enter a word:word =abcdefghijklmnopqrstuvwxyz length = 26
+
+End of test
diff --git a/gnu/egcs/libstdc++/tests/tstring.inp b/gnu/egcs/libstdc++/tests/tstring.inp
new file mode 100644
index 00000000000..b0883f382e1
--- /dev/null
+++ b/gnu/egcs/libstdc++/tests/tstring.inp
@@ -0,0 +1 @@
+abcdefghijklmnopqrstuvwxyz
diff --git a/gnu/egcs/libstdc++/tests/tvector.cc b/gnu/egcs/libstdc++/tests/tvector.cc
new file mode 100644
index 00000000000..ef238ef52da
--- /dev/null
+++ b/gnu/egcs/libstdc++/tests/tvector.cc
@@ -0,0 +1,20 @@
+#include <vector.h>
+#include <iostream.h>
+#include <algo.h>
+
+main ()
+{
+  cout << "Fill of C array:\n";
+  char x[50];
+  fill (x, x+50, '/');
+  fill (x+1, x+49, '*');
+  copy (x, x+50, ostream_iterator<char>(cout));
+
+  cout << "\nFill of vector<char>:\n";
+
+  vector<char> cvec;
+  cvec.insert (cvec.begin(), 50, '/');
+  fill (cvec.begin()+1, cvec.end()-1, '-');
+  copy (cvec.begin(), cvec.end(), ostream_iterator<char>(cout));
+  cout << endl;
+}
diff --git a/gnu/egcs/libstdc++/tests/tvector.exp b/gnu/egcs/libstdc++/tests/tvector.exp
new file mode 100644
index 00000000000..84a9d1bf3a4
--- /dev/null
+++ b/gnu/egcs/libstdc++/tests/tvector.exp
@@ -0,0 +1,4 @@
+Fill of C array:
+/************************************************/
+Fill of vector<char>:
+/------------------------------------------------/
diff --git a/gnu/egcs/libstdc++/testsuite/ChangeLog b/gnu/egcs/libstdc++/testsuite/ChangeLog
new file mode 100644
index 00000000000..7b1a9f0c3c5
--- /dev/null
+++ b/gnu/egcs/libstdc++/testsuite/ChangeLog
@@ -0,0 +1,74 @@
+Wed Nov 25 01:00:07 1998  Marc Espie <espie@quatramaran.ens.fr>
+
+	* Makefile.in (just-check): Ignore errors.
+
+Sun Jun 28 00:00:10 1998   Carlo Wood  <carlo@runaway.xs4all.nl>
+
+        * lib/libstdc++.exp: Use global variable ld_library_path (not local)
+	that is a lot more persistent; dejagnu-980528 needs this.
+	* lib/libstdc++.exp (test_stdc++): Use regular expression " -lstdc.."
+	to remove -lstdc++ arguments (not " -lstdc.*").
+
+Thu Dec 25 00:34:03 1997  Jeffrey A Law  (law@cygnus.com)
+
+	* lib/libstdc++.exp (test_libstdc++): Set LD_LIBRARY_PATH
+	and SHLIB_PATH appropriately.
+
+Wed Sep  3 09:39:36 1997  Jeffrey A Law  (law@cygnus.com)
+
+	* lib/libstdc++.exp: Remove libg++_link_flags.
+
+Wed Aug  6 18:43:23 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* lib/libstdc++.exp: Remove libio_link_flags.
+
+Thu Jul 17 14:54:58 1997  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* lib/libstdc++.exp (base_dir): Move from here...
+	(test_libstdc++): To here.
+	(LIBSTDCPP): Delete unused global decl.
+
+Tue Jun 17 01:46:49 1997  Bob Manson  <manson@farmer>
+
+	* lib/libstdc++.exp: Strip off leading LFs from both the pattern
+ 	being matched against and the output from the board. Find the
+ 	correct multilib libstdc++ to link with. Use g++_link_flags
+ 	and libio_link_flags. Link in the status wrapper if needed.
+	(libstdc++_init): New procedure.
+
+Tue Jun  3 17:16:39 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/libstdc++.exp: Don't use global exec_output variable; the
+ 	output is returned from remote_load instead.
+
+Tue Apr 29 17:20:05 1997  Mike Stump  <mrs@cygnus.com>
+
+	* lib/libstdc++.exp: Fixup so that $compile_args works better.
+	* libstdc++.tests/test.exp: Also run with -O.
+
+Tue Apr 29 16:34:37 1997  Mike Stump  <mrs@cygnus.com>
+
+	* testsuite/lib/libstdc++.exp: Fixup so that we always have the
+ 	same number of testcases, and so that we have meaningful testcase
+ 	names.
+
+Tue Apr 29 13:05:14 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/libstdc++.exp: Add support for --tool_opts.
+
+Mon Apr 28 11:10:25 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* Makefile.in: Add comment so target Makefile fragments get added.
+	Removed clean rule, because it is added by configure.
+
+	* configure.in (TESTS): Add.
+
+Sun Apr 27 15:03:10 1997  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* Makefile.in (clean): Add empty rule for now.
+
+Fri Apr 25 18:59:14 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/libstdc++.exp(test_libstdc++): Return on error. Generate a
+ 	FAIL if the compile fails. Remove CRs from the output from the
+ 	testcase.
diff --git a/gnu/egcs/libstdc++/testsuite/Makefile.in b/gnu/egcs/libstdc++/testsuite/Makefile.in
new file mode 100644
index 00000000000..7c85678e1fe
--- /dev/null
+++ b/gnu/egcs/libstdc++/testsuite/Makefile.in
@@ -0,0 +1,67 @@
+# Copyright (C) 1997 Free Software Foundation
+# 
+# This file is part of the GNU IO 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 GNU CC; see the file COPYING.  If not, write to
+# the Free Software Foundation, 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.  */
+
+srcdir = libstdc++.tests
+
+EXPECT = `if [ -f $${rootme}/../../expect/expect ] ; then \
+            echo $${rootme}/../../expect/expect ; \
+          else echo expect ; fi`
+
+RUNTEST = `if [ -f $${srcdir}/../../dejagnu/runtest ] ; then \
+	       echo $${srcdir}/../../dejagnu/runtest ; \
+	    else echo runtest; fi`
+RUNTESTFLAGS =
+
+#### package, host, target, and site dependent Makefile fragments come in here.
+##
+
+.PHONY: all
+all:
+
+.PHONY: check
+check: all just-check
+
+site.exp: ./config.status Makefile
+	@echo "Making a new config file..."
+	-@rm -f ./tmp?
+	@touch site.exp
+	-@mv site.exp site.bak
+	@echo "## these variables are automatically generated by make ##" > ./tmp0
+	@echo "# Do not edit here. If you wish to override these values" >> ./tmp0
+	@echo "# add them to the last section" >> ./tmp0
+	@echo "set host_alias $(host_alias)" >> ./tmp0
+	@echo "set host_triplet ${host_canonical}" >> ./tmp0
+	@echo "set target_alias $(target_alias)" >> ./tmp0
+	@echo "set target_triplet ${target_canonical}" >> ./tmp0
+	@echo "set build_triplet ${build_canonical}" >> ./tmp0
+	@echo "set srcdir ${srcdir}" >> ./tmp0
+	@echo "set tool libstdc++" >> ./tmp0
+	@echo "## All variables above are generated by configure. Do Not Edit ##" >> ./tmp0
+		@cat ./tmp0 > site.exp
+	@cat site.bak | sed \
+			-e '1,/^## All variables above are.*##/ d' >> site.exp
+	-@rm -f ./tmp?
+
+just-check: site.exp
+	-rootme=`pwd`; export rootme; \
+	srcdir=${srcdir} ; export srcdir ; \
+	EXPECT=${EXPECT} ; export EXPECT ; \
+	if [ -f $${rootme}/../../expect/expect ] ; then  \
+	  TCL_LIBRARY=$${srcdir}/../../tcl/library ; \
+	  export TCL_LIBRARY ; fi ; \
+	$(RUNTEST) $(RUNTESTFLAGS) 
diff --git a/gnu/egcs/libstdc++/testsuite/config/default.exp b/gnu/egcs/libstdc++/testsuite/config/default.exp
new file mode 100644
index 00000000000..90967cccc18
--- /dev/null
+++ b/gnu/egcs/libstdc++/testsuite/config/default.exp
@@ -0,0 +1 @@
+load_lib "standard.exp"
diff --git a/gnu/egcs/libstdc++/testsuite/configure.in b/gnu/egcs/libstdc++/testsuite/configure.in
new file mode 100644
index 00000000000..ad5f232b085
--- /dev/null
+++ b/gnu/egcs/libstdc++/testsuite/configure.in
@@ -0,0 +1,24 @@
+# This file is a shell script fragment that supplies the information
+# necessary for a configure script to process the program in
+# this directory.  For more information, look at ../../configure.
+
+configdirs=
+srctrigger=configure.in
+srcname="tests for ANSI C++ library, dejagnu style"
+package_makefile_frag=Make.pack
+package_makefile_rules_frag=Make.pack.r
+
+# per-host:
+
+# per-target:
+
+target_makefile_frag=../target-mkfrag
+
+TO_TOPDIR=../../
+ALL=' '
+XCXXINCLUDES="-I${srcdir}/.. -I${srcdir}/../stl -I${TO_TOPDIR}libio -I${srcdir}/${TO_TOPDIR}libio"
+TESTS="tcomplex tstring tlist tmap tvector"
+MOSTLYCLEAN="*.o core ${TESTS} *.out"
+(. ${srcdir}/${TO_TOPDIR}libio/config.shared) >${package_makefile_frag} 2>${package_makefile_rules_frag}
+
+# post-target:
diff --git a/gnu/egcs/libstdc++/testsuite/lib/libstdc++.exp b/gnu/egcs/libstdc++/testsuite/lib/libstdc++.exp
new file mode 100644
index 00000000000..3333ddad6c7
--- /dev/null
+++ b/gnu/egcs/libstdc++/testsuite/lib/libstdc++.exp
@@ -0,0 +1,179 @@
+# Copyright (C) 1997 Free Software Foundation, Inc.
+
+# This program 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 of the License, or
+# (at your option) any later version.
+# 
+# This program 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 program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-lib-g++@prep.ai.mit.edu
+
+# This file was written by Bob Manson. (manson@cygnus.com)
+
+load_lib "libgloss.exp"
+
+global tmpdir
+
+if ![info exists tmpdir] {
+    set tmpdir "/tmp"
+}
+
+#
+# Build the status wrapper library as needed.
+#
+proc libstdc++_init { args } {
+    global wrapper_file;
+    global wrap_compile_flags;
+    set wrapper_file "";
+    set wrap_compile_flags "";
+    if [target_info exists needs_status_wrapper] {
+	set result [build_wrapper "testglue.o"];
+	if { $result != "" } {
+	    set wrapper_file [lindex $result 0];
+	    set wrap_compile_flags [lindex $result 1];
+	} else {
+	    warning "Status wrapper failed to build."
+	}
+    }
+}
+#
+# Run the test specified by srcfile and resultfile. compile_args and
+# exec_args are additional arguments to be passed in when compiling and
+# running the testcase, respectively.
+#
+
+proc test_libstdc++ { options srcfile compile_args inpfile resultfile exec_args } {
+    global base_dir
+    global LIBSTDCPP
+    global srcdir subdir objdir
+    global TOOL_OPTIONS
+    global ld_library_path
+
+    if [info exists LIBSTDCPP] {
+	set libstdcpp $LIBSTDCPP;
+    } else {
+	set gp [get_multilibs];
+	if { $gp != "" } {
+	    if [file exists "$gp/libstdc++/libstdc++.a"] {
+		set libstdcpp "-L$gp/libstdc++ -lstdc++";
+	    }
+	}
+	if ![info exists libstdcpp] {
+	set libstdcpp [findfile $base_dir/../../libstdc++/libstdc++.a "-L$base_dir/../../libstdc++ -lstdc++" -lstdc++]
+	}
+    }
+
+    verbose "using LIBSTDCPP = $libstdcpp" 2
+    set args ""
+
+    # Basically we want to build up a colon separated path list from
+    # the value of $libstdcpp.
+
+    # First strip away any -L arguments.
+    regsub -all -- "-L" $libstdcpp "" ld_library_path
+
+    # Then remove any -lstdc++ argument.
+    regsub -all -- " -lstdc.." $ld_library_path "" ld_library_path
+
+    # That's enough to make things work for the normal case.
+    # If we wanted to handle an arbitrary value of libstdcpp,
+    # then we'd have to do a lot more work.
+
+    if { $compile_args != "" } {
+	lappend args "additional_flags=$compile_args"
+    }
+    lappend args "incdir=.."
+    lappend args "incdir=$srcdir/.."
+    lappend args "incdir=$srcdir/../stl"
+    lappend args "incdir=."
+    if [info exists TOOL_OPTIONS] {
+	lappend args "additional_flags=$TOOL_OPTIONS"
+    }
+
+    global wrapper_file wrap_compile_flags;
+    # We have to include libio, for _G_config.h.
+    lappend args "additional_flags=$wrap_compile_flags";
+    lappend args "libs=$wrapper_file";
+    lappend args "libs=$libstdcpp";
+    lappend args "additional_flags=[libio_include_flags]"
+    lappend args debug
+
+    regsub "^.*/(\[^/.\]+)\[.\]\[^/]*$" "$srcfile" "\\1" out
+    set executable "${objdir}/$out"
+    set errname "[file tail $srcfile]"
+    if { $compile_args != "" } {
+	set errname "$errname $compile_args"
+    }
+
+    if { [target_compile $srcfile "$executable" executable $args] != "" } {
+	fail "$errname compilation"
+	setup_xfail "*-*-*"
+	fail "$errname execution"
+	setup_xfail "*-*-*"
+	fail "$errname output"
+	return;
+    }
+    pass "$errname compilation"
+
+    set result [libstdc++_load $executable "$exec_args" "$inpfile"];
+    set status [lindex $result 0];
+    set output [lindex $result 1];
+    $status "$errname execution"
+    if { $status != "pass" } {
+	setup_xfail "*-*-*"
+	fail "$errname output"
+	return;
+    }
+
+    verbose "resultfile is $resultfile"
+    set id [open $resultfile r];
+    set expected ""
+    append expected [read $id];
+    regsub -all "\r" "$output" "" output;
+    regsub "\n*$" $expected "" expected
+    regsub "\n*$" $output "" output
+    regsub "^\n*" $expected "" expected
+    regsub "^\n*" $output "" output
+    regsub -all "\[ \t\]\[ \t\]*" $expected " " expected
+    regsub -all "\[ \t\]*\n\n*" $expected "\n" expected
+    regsub -all "\[ \t\]\[ \t\]*" $output " " output
+    regsub -all "\[ \t\]*\n\n*" $output "\n" output
+    verbose "expected is $expected"
+    verbose "actual is $output"
+    set passed 0;
+    if {$options == "regexp_match"} {
+	if [regexp $expected $output] {
+	    set passed 1;
+	}
+    } else {
+	if { $expected == $output } {
+	    set passed 1;
+	}
+    }
+    if { $passed == 1 } {
+	pass "$errname output"
+    } else {
+	clone_output "expected was $expected"
+	clone_output "output was $output"
+	fail "$errname output"
+    }
+    close $id;
+}
+
+#
+# libstdc++_version -- extract and print the version number of libstdc++p
+#
+proc default_libstdc++_version {} {
+}
+
+proc default_libstdc++_start { } {
+}
diff --git a/gnu/egcs/libstdc++/testsuite/libstdc++.tests/test.exp b/gnu/egcs/libstdc++/testsuite/libstdc++.tests/test.exp
new file mode 100644
index 00000000000..7368cfb282e
--- /dev/null
+++ b/gnu/egcs/libstdc++/testsuite/libstdc++.tests/test.exp
@@ -0,0 +1,34 @@
+global srcdir subdir
+
+catch "glob -nocomplain $srcdir/$subdir/../../tests/*.exp" srcfiles
+verbose "srcfiles are $srcfiles"
+
+set prefix ""
+foreach x $srcfiles {
+    regsub "\\.exp$" $x "" prefix
+    set bname [file tail $prefix]
+    set args ""
+    if [file exists $srcdir/$subdir/${bname}.arg] {
+	set id [open "$srcdir/$subdir/${bname}.arg" r];
+	set args [read -nonewline $id];
+	close $id;
+    }
+    if [file exists $srcdir/$subdir/${bname}.xpo] {
+	set resfile "$srcdir/$subdir/${bname}.xpo"
+	set options "regexp_match"
+    } else {
+	set resfile "${prefix}.exp"
+	set options ""
+    }
+
+    if [file exists ${prefix}.inp] {
+	set inpfile ${prefix}.inp
+    } else {
+	set inpfile ""
+    }
+
+    verbose "inpfile is $inpfile"
+
+    test_libstdc++ $options "${prefix}.cc" "" $inpfile $resfile $args
+    test_libstdc++ $options "${prefix}.cc" "-O" $inpfile $resfile $args
+}