Add additional stlport files

71 files changed, 19248 insertions, 0 deletions

diff --git a/stlport/configure b/stlport/configure
new file mode 100755
index 0000000..2f48511
--- /dev/null
+++ b/stlport/configure
@@ -0,0 +1,333 @@
+#!/bin/sh
+
+# Time-stamp: <08/06/07 15:22:19 yeti>
+
+base=`cd \`dirname $0\`; echo $PWD`
+
+configmak=$base/build/Makefiles/gmake/config.mak
+
+write_option() {
+  target=`echo $1 | sed -e 's/^[^=]*=//'`
+  echo $2 := $3$target >> ${configmak}
+}
+
+write_over_option() {
+  target=`echo $1 | sed -e 's/^[^=]*=//'`
+  echo $2 ?= $target >> ${configmak}
+}
+
+print_help() {
+  cat <<EOF
+Configuration utility.
+
+Usage:
+
+  configure [options]
+
+Available options:
+
+  --prefix=<dir>        base install path (/usr/local/)
+  --bindir=<dir>        install path for executables (PREFIX/bin)
+  --libdir=<dir>        install path for libraries (PREFIX/lib)
+  --includedir=<dir>    install path for headers (PREFIX/include)
+
+  --target=<target>     target platform (cross-compiling)
+
+  --help                print this help message and exit
+
+  --with-stlport=<dir>  use STLport in catalog <dir>
+  --without-stlport     compile without STLport
+  --with-boost=<dir>    use boost headers in catalog <dir>
+  --with-system-boost   use boost installed on this system
+  --with-msvc=<dir>     use MS VC from this catalog
+  --with-mssdk=<dir>    use MS SDK from this catalog
+  --with-extra-cxxflags=<options>
+                        pass extra options to C++ compiler
+  --with-extra-cflags=<options>
+                        pass extra options to C compiler
+  --with-extra-ldflags=<options>
+                        pass extra options to linker (via C/C++)
+  --use-static-gcc      use static gcc libs instead of shared libgcc_s (useful for gcc compiler,
+                        that was builded with --enable-shared [default]; if compiler was builded
+                        with --disable-shared, static libraries will be used in any case)
+  --clean               remove custom settings (file ${configmak})
+                        and use default values
+  --with-cxx=<name>     use <name> as C++ compiler (use --target= for cross-compilation)
+  --with-cc=<name>      use <name> as C compiler (use --target= for cross-compilation)
+  --use-compiler-family=<name> use compiler family; one of:
+                        gcc      GNU compilers (default)
+                        icc      Intel compilers
+                        aCC      HP's aCC compilers
+                        CC       SunPro's CC compilers
+                        bcc      Borland's compilers
+  --without-debug       don't build debug variant
+  --without-stldebug    don't build STLport's STLP_DEBUG mode
+  --enable-static       build static
+  --disable-shared      don't build shared 
+  --with-lib-motif=<motif>
+                        Use this option to customize the generated library name.
+                        The motif will be used in the last place before version information,
+                        separated by an underscore, ex:
+                        stlportd_MOTIF.5.0.lib
+                        stlportstld_static_MOTIF.5.1.lib
+  --without-thread      Per default STLport libraries are built in order to be usable
+                        in a multithreaded context. If you don't need this you can ask
+                        for a not thread safe version with this option.
+  --without-rtti        Disable RTTI when building libraries.
+  --with-static-rtl
+  --with-dynamic-rtl
+                        Enables usage of static (libc.lib family) or dynamic (msvcrt.lib family)
+                        C/C++ runtime library when linking with STLport. If you want your appli/dll
+                        to link statically with STLport but using the dynamic C runtime use
+                        --with-dynamic-rtl; if you want to link dynamicaly with STLport but using the
+                        static C runtime use --with-static-rtl. See README.options for details.
+                        Don't forget to signal the link method when building your appli or dll, in
+                        stlport/stl/config/host.h set the following macro depending on the configure
+                        option:
+                        --with-static-rtl  -> _STLP_USE_DYNAMIC_LIB"
+                        --with-dynamic-rtl -> _STLP_USE_STATIC_LIB"
+  --windows-platform=<name>
+                        Targetted OS when building for Windows; one of:
+                        win95   Windows 95
+                        win98   Windows 98
+                        winxp   Windows XP and later (default)
+
+Environment variables:
+
+  \$CXX                 C++ compiler name (use --target= for cross-compilation)
+  \$CC                  C compiler name (use --target= for cross-compilation)
+  \$CXXFLAGS            pass extra options to C++ compiler
+  \$CFLAGS              pass extra options to C compiler
+  \$LDFLAGS             pass extra options to linker (via C/C++)
+
+  Options has preference over environment variables.
+
+EOF
+}
+
+default_settings () {
+  # if [ "$boost_set" = "" ]; then
+  #   write_option "${PWD}/external/boost" BOOST_DIR
+  # fi
+
+  # if [ -z "${stlport_set}" ]; then
+  #   write_over_option "$base" STLPORT_DIR
+  # fi
+
+  # Set in Makefiles/gmake/top.mak
+  if [ -z "${compiler_family_set}" ]; then
+  #  write_option gcc COMPILER_NAME
+    echo include gcc.mak > ${base}/build/lib/Makefile
+    echo include gcc.mak > ${base}/build/test/unit/Makefile
+    echo include gcc.mak > ${base}/build/test/eh/Makefile
+  fi
+
+  # Set in Makefiles/gmake/targetdirs.mak
+  # if [ -z "${prefix_set}" ]; then
+  #   write_option "/usr/local" BASE_INSTALL_DIR '${DESTDIR}'
+  # fi
+}
+
+[ $# -eq 0 ] && { >${configmak}; default_settings; exit 0; }
+
+for a in $@ ; do
+  case $a in
+    --help)
+      print_help
+      exit 0
+      ;;
+    --clean)
+      rm -f ${configmak}
+      exit 0
+      ;;
+  esac
+done
+
+>${configmak}
+
+while :
+do
+  case $# in
+    0)
+      break
+      ;;
+  esac
+  option="$1"
+  shift
+  case $option in
+    --target=*)
+      write_option "$option" TARGET_OS
+      target_set=y
+      ;;
+    --with-stlport=*)
+      write_option "$option" STLPORT_DIR
+      stlport_set=y
+      ;;
+    --without-stlport)
+      write_option 1 WITHOUT_STLPORT
+      stlport_set=y
+      ;;
+    --with-boost=*)
+      write_option "$option" BOOST_DIR
+      ;;
+    --with-system-boost)
+      write_option 1 USE_SYSTEM_BOOST
+      ;;
+    --with-msvc=*)
+      write_option "$option" MSVC_DIR
+      ;;
+    --with-mssdk=*)
+      write_option "$option" MSSDK_DIR
+      ;;
+    --with-extra-cxxflags=*)
+      write_option "$option" EXTRA_CXXFLAGS
+      cxxflags_set=y
+      ;;
+    --with-extra-cflags=*)
+      write_option "$option" EXTRA_CFLAGS
+      cflags_set=y
+      ;;
+    --with-extra-ldflags=*)
+      write_option "$option" EXTRA_LDFLAGS
+      ldflags_set=y
+      ;;
+    --with-lib-motif=*)
+      echo "Using $option in generated library names"
+      write_option "$option" LIB_MOTIF
+      ;;
+    --without-thread)
+      write_option 1 WITHOUT_THREAD
+      ;;
+    --without-rtti)
+      write_option 1 WITHOUT_RTTI
+      ;;
+    --with-dynamic-rtl)
+      write_option 1 WITH_DYNAMIC_RTL
+      ;;
+    --with-static-rtl)
+      write_option 1 WITH_STATIC_RTL
+      ;;
+    --use-static-gcc)
+      write_option 1 USE_STATIC_LIBGCC
+      ;;
+    --without-debug)
+      write_option 1 _NO_DBG_BUILD
+      ;;
+    --without-stldebug)
+      write_option 1 _NO_STLDBG_BUILD
+      ;;
+    --enable-static)
+      write_option 1 _STATIC_BUILD
+      ;;
+    --disable-shared)
+      write_option 1 _NO_SHARED_BUILD
+      ;;
+    --with-cxx=*)
+      write_option "$option" _FORCE_CXX
+      cxx_set=y
+      ;;
+    --with-cc=*)
+      write_option "$option" _FORCE_CC
+      cc_set=y
+      ;;
+    --use-compiler-family=*)
+      case `echo $option | sed -e 's/^[^=]*=//'` in
+        gcc|icc|aCC|CC|bcc|dmc)
+          target=`echo $option | sed -e 's/^[^=]*=//'`
+          echo COMPILER_NAME := $target >> ${configmak}
+          echo include $target.mak > ${base}/build/lib/Makefile
+          echo include $target.mak > ${base}/build/test/unit/Makefile
+          echo include $target.mak > ${base}/build/test/eh/Makefile
+          ;;
+        *)
+          echo "Not supported compilers family"
+          exit -1
+          ;;
+      esac
+      compiler_family_set=y
+      ;;
+    --prefix=*)
+      write_option "$option" BASE_INSTALL_DIR '${DESTDIR}'
+      prefix_set=y
+      ;;
+    --bindir=*)
+      write_option "$option" INSTALL_BIN_DIR '${DESTDIR}'
+      ;;
+    --libdir=*)
+      write_option "$option" INSTALL_LIB_DIR '${DESTDIR}'
+      ;;
+    --includedir=*)
+      write_option "$option" INSTALL_HDR_DIR '${DESTDIR}'
+      ;;
+    --windows-platform=*)
+      case `echo $option | sed -e 's/^[^=]*=//'` in
+        win95)
+          write_option 0x0400 WINVER
+          ;;
+        win98)
+          write_option 0x0410 WINVER
+          ;;
+        winxp)
+          write_option 0x0501 WINVER
+          ;;
+        *)
+          echo "Not supported windows platform"
+          exit -1
+          ;;
+      esac
+      ;;
+    *)
+      echo "Unknown configuration option '$option'"
+      exit -1
+      ;;
+  esac
+done
+
+if [ -n "${CXX}" ]; then
+  if [ -n "${cxx_set}" ]; then
+    echo "Both --with-cxx and \$CXX set, using the first"
+  elif [ -z "${target_set}" ]; then
+    write_option "${CXX}" _FORCE_CXX
+  else
+    echo "For cross-compilation with gcc use --target option only"
+  fi
+  if [ -z "${CC}" -a -z "${cc_set}" ]; then
+    echo "\$CXX set, but I don't see \$CC!"
+  fi
+fi
+
+if [ -n "${CC}" ]; then
+  if [ -n "${cxx_set}" ]; then
+    echo "Both --with-cc and \$CC set, using the first"
+  else
+    write_option "${CC}" _FORCE_CC
+  fi
+fi
+
+if [ -n "${CXXFLAGS}" ]; then
+  if [ -z "${cxxflags_set}" ]; then
+    write_option "${CXXFLAGS}" EXTRA_CXXFLAGS
+  else
+    echo "Both --with-extra-cxxflags and \$CXXFLAGS set, using the first"
+  fi
+fi
+
+if [ -n "${CFLAGS}" ]; then
+  if [ -z "${cflags_set}" ]; then
+    write_option "${CFLAGS}" EXTRA_CFLAGS
+  else
+    echo "Both --with-extra-cflags and \$CFLAGS set, using the first"
+  fi
+fi
+
+if [ -n "${LDFLAGS}" ]; then
+  if [ -z "${ldflags_set}" ]; then
+    write_option "${LDFLAGS}" EXTRA_LDFLAGS
+  else
+    echo "Both --with-extra-ldflags and \$LDFLAGS set, using the first"
+  fi
+fi
+
+# default settings
+
+default_settings
diff --git a/stlport/stlport/algorithm b/stlport/stlport/algorithm
new file mode 100644
index 0000000..c653d8c
--- /dev/null
+++ b/stlport/stlport/algorithm
@@ -0,0 +1,62 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_ALGORITHM
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+#  define _STLP_OUTERMOST_HEADER_ID 0x1
+#  include <stl/_prolog.h>
+#  define _STLP_ALGORITHM
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1)
+#  ifndef _STLP_INTERNAL_CSTDIO
+// remove() conflicts, <cstdio> should always go first
+#    include <stl/_cstdio.h>
+#  endif
+
+#  ifndef _STLP_INTERNAL_ALGO_H
+#    include <stl/_algo.h>
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x1) || defined (_STLP_IMPORT_VENDOR_STD)
+#  if defined (_STLP_HAS_INCLUDE_NEXT)
+#    include_next <algorithm>
+#  else
+#    include _STLP_NATIVE_HEADER(algorithm)
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1 )
+#  include <stl/_epilog.h>
+#  undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_ALGORITHM */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/bitset b/stlport/stlport/bitset
new file mode 100644
index 0000000..1d7fcf3
--- /dev/null
+++ b/stlport/stlport/bitset
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_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.
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+#  define _STLP_OUTERMOST_HEADER_ID 0x2
+#  include <stl/_prolog.h>
+#  define _STLP_BITSET
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x2)
+#  ifndef _STLP_INTERNAL_BITSET
+#    include <stl/_bitset.h>
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x2) || defined (_STLP_IMPORT_VENDOR_STD)
+#  if defined (_STLP_HAS_INCLUDE_NEXT)
+#    include_next <bitset>
+#  else
+#    include _STLP_NATIVE_HEADER(bitset)
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x2 )
+#  include <stl/_epilog.h>
+#  undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_BITSET */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/cctype b/stlport/stlport/cctype
new file mode 100644
index 0000000..513512e
--- /dev/null
+++ b/stlport/stlport/cctype
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CCTYPE
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+#  define _STLP_OUTERMOST_HEADER_ID 0x104
+#  define _STLP_CCTYPE
+#  include <stl/_prolog.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x104 )
+#  ifndef _STLP_INTERNAL_CCTYPE
+#    include <stl/_cctype.h>
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x104) || defined (_STLP_IMPORT_VENDOR_STD)
+#  if defined (_STLP_HAS_INCLUDE_NEXT)
+#    include_next <cctype>
+#  else
+#    include _STLP_NATIVE_CPP_C_HEADER(cctype)
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x104 )
+#  include <stl/_epilog.h>
+#  undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_CCTYPE */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/cfloat b/stlport/stlport/cfloat
new file mode 100644
index 0000000..cb2e0cd
--- /dev/null
+++ b/stlport/stlport/cfloat
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CFLOAT
+#define _STLP_CFLOAT
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+#  define _STLP_OUTERMOST_HEADER_ID 0x106
+#  include <stl/_prolog.h>
+#endif
+
+// Borland defines some implementation constants in std:: namespace,
+// we do not want to import them.
+#if defined  (_STLP_USE_NEW_C_HEADERS) && !defined (__BORLANDC__)
+#  if defined (_STLP_HAS_INCLUDE_NEXT)
+#    include_next <cfloat>
+#  else
+#    include _STLP_NATIVE_CPP_C_HEADER(cfloat)
+#  endif
+#else
+#  include <float.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x106 )
+#  include <stl/_epilog.h>
+#  undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_CFLOAT */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/cstdio b/stlport/stlport/cstdio
new file mode 100644
index 0000000..e20c8ff
--- /dev/null
+++ b/stlport/stlport/cstdio
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CSTDIO
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+#  define _STLP_OUTERMOST_HEADER_ID 0x15
+#  include <stl/_prolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x15) && !defined (_STLP_DONT_POP_HEADER_ID)
+#  define _STLP_DONT_POP_HEADER_ID
+#  define _STLP_CSTDIO
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x15) && !defined (_STLP_DONT_POP_HEADER_ID)
+#  ifndef _STLP_INTERNAL_CSTDIO
+#    include <stl/_cstdio.h>
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x15) || defined (_STLP_DONT_POP_HEADER_ID) || defined (_STLP_IMPORT_VENDOR_STD)
+#  if defined (_STLP_HAS_INCLUDE_NEXT)
+#    include_next <cstdio>
+#  else
+#    include _STLP_NATIVE_CPP_C_HEADER(cstdio)
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x15)
+#  if !defined (_STLP_DONT_POP_HEADER_ID)
+#    include <stl/_epilog.h>
+#    undef _STLP_OUTERMOST_HEADER_ID
+#  else
+#    undef _STLP_DONT_POP_HEADER_ID
+#  endif
+#endif
+
+#endif
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/cstring b/stlport/stlport/cstring
new file mode 100644
index 0000000..d5cf58d
--- /dev/null
+++ b/stlport/stlport/cstring
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CSTRING
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+#  define _STLP_OUTERMOST_HEADER_ID 0x117
+#  define _STLP_CSTRING
+#  include <stl/_prolog.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x117)
+#  ifndef _STLP_INTERNAL_CSTRING
+#    include <stl/_cstring.h>
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x117) || defined (_STLP_IMPORT_VENDOR_STD)
+#  if defined (_STLP_HAS_INCLUDE_NEXT)
+#    include_next <cstring>
+#  else
+#    include _STLP_NATIVE_CPP_C_HEADER(cstring)
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x117)
+#  include <stl/_epilog.h>
+#  undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_CSTRING */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/deque b/stlport/stlport/deque
new file mode 100644
index 0000000..448f159
--- /dev/null
+++ b/stlport/stlport/deque
@@ -0,0 +1,57 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_DEQUE
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+#  define _STLP_OUTERMOST_HEADER_ID 0x22
+#  include <stl/_prolog.h>
+#  define _STLP_DEQUE
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x22)
+#  ifndef _STLP_INTERNAL_DEQUE_H
+#    include <stl/_deque.h>
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x22) || defined (_STLP_IMPORT_VENDOR_STD)
+#  if defined (_STLP_HAS_INCLUDE_NEXT)
+#    include_next <deque>
+#  else
+#    include _STLP_NATIVE_HEADER(deque)
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x22)
+#  include <stl/_epilog.h>
+#  undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_DEQUE */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/exception b/stlport/stlport/exception
new file mode 100644
index 0000000..47822e9
--- /dev/null
+++ b/stlport/stlport/exception
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+// This header exists solely for portability.  Normally it just includes
+// the native header <exception>.
+
+#ifndef _STLP_EXCEPTION
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+#  define _STLP_OUTERMOST_HEADER_ID 0x423
+#  include <stl/_prolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x423)
+#  define _STLP_DONT_POP_HEADER_ID
+#  define _STLP_EXCEPTION
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x423) && !defined (_STLP_DONT_POP_HEADER_ID)
+#  ifndef _STLP_INTERNAL_EXCEPTION
+#    include <stl/_exception.h>
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x423) || defined (_STLP_DONT_POP_HEADER_ID) || defined (_STLP_IMPORT_VENDOR_STD)
+/* If we are here it means that we are in an include called 
+ * from the native lib which means that we can simply forward this
+ * call to the native exception header:
+ */
+#  if defined (_STLP_HAS_INCLUDE_NEXT)
+#    include_next <exception>
+#  else
+#    if defined (__DMC__) && (_STLP_OUTERMOST_HEADER_ID == 0x874)
+// Workaround to DMC harcoded typeinfo.h inclusion.
+#      include <../include/exception>
+#    else
+#      include _STLP_NATIVE_CPP_RUNTIME_HEADER(exception)
+#    endif
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x423)
+#  if !defined(_STLP_DONT_POP_HEADER_ID)
+#    include <stl/_epilog.h>
+#    undef  _STLP_OUTERMOST_HEADER_ID
+#  else
+#    undef  _STLP_DONT_POP_HEADER_ID
+#  endif
+#endif
+
+#endif /* _STLP_EXCEPTION */
+
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/float.h b/stlport/stlport/float.h
new file mode 100644
index 0000000..70fe3ad
--- /dev/null
+++ b/stlport/stlport/float.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+#  define _STLP_OUTERMOST_HEADER_ID 0x203
+#  include <stl/_cprolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x203) && !defined (_STLP_DONT_POP_HEADER_ID)
+#  define _STLP_DONT_POP_HEADER_ID
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x203)
+#  error This header is only reentrant once, it should be modified if it has to be included more.
+#endif
+
+#if defined (_STLP_WCE_EVC3)
+struct _exception;
+#endif
+
+#if defined (_STLP_HAS_INCLUDE_NEXT)
+#  include_next <float.h>
+#else
+#  include _STLP_NATIVE_C_HEADER(float.h)
+#endif
+
+#if !defined (__linux__)
+#  if defined(__BORLANDC__) && defined (__cplusplus) && (__BORLANDC__ >= 0x560)
+_STLP_BEGIN_NAMESPACE
+using ::_max_dble;
+using ::_max_flt;
+using ::_max_ldble;
+using ::_tiny_ldble;
+_STLP_END_NAMESPACE
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x203)
+#  if ! defined (_STLP_DONT_POP_HEADER_ID)
+#    include <stl/_epilog.h>
+#    undef  _STLP_OUTERMOST_HEADER_ID
+#  endif
+#  undef  _STLP_DONT_POP_HEADER_ID
+#endif
diff --git a/stlport/stlport/hash_map b/stlport/stlport/hash_map
new file mode 100644
index 0000000..0e2422d
--- /dev/null
+++ b/stlport/stlport/hash_map
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_HASH_MAP
+#define _STLP_HASH_MAP
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+#  define _STLP_OUTERMOST_HEADER_ID 0x4028
+#  include <stl/_prolog.h>
+#endif
+
+#ifdef _STLP_PRAGMA_ONCE
+#  pragma once
+#endif
+
+#if defined (_STLP_NO_EXTENSIONS)
+/* Comment following if you want to use hash constainers even if you ask for
+ * no extension.
+ */
+#  error The hash_map and hash_multimap class are STLport extensions.
+#endif
+
+#include <stl/_hash_map.h>
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x4028)
+#  include <stl/_epilog.h>
+#  undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_HASH_MAP */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/hash_set b/stlport/stlport/hash_set
new file mode 100644
index 0000000..0fc89ec
--- /dev/null
+++ b/stlport/stlport/hash_set
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_HASH_SET
+#define _STLP_HASH_SET
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+#  define _STLP_OUTERMOST_HEADER_ID 0x4029
+#  include <stl/_prolog.h>
+#endif
+
+#ifdef _STLP_PRAGMA_ONCE
+#  pragma once
+#endif
+
+#if defined (_STLP_NO_EXTENSIONS)
+/* Comment following if you want to use hash constainers even if you ask for
+ * no extension.
+ */
+#  error The hash_set and hash_multiset class are STLport extensions.
+#endif
+
+#include <stl/_hash_set.h>
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x4029)
+#  include <stl/_epilog.h>
+#  undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_HASH_SET */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/limits b/stlport/stlport/limits
new file mode 100644
index 0000000..5333b14
--- /dev/null
+++ b/stlport/stlport/limits
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_LIMITS
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+#  define _STLP_OUTERMOST_HEADER_ID 0x39
+#  include <stl/_prolog.h>
+#  define _STLP_LIMITS
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x39)
+#  ifndef _STLP_INTERNAL_LIMITS
+#    include <stl/_limits.h>
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x39) || defined (_STLP_IMPORT_VENDOR_STD)
+#  if defined (_STLP_HAS_INCLUDE_NEXT)
+#    include_next <limits>
+#  else
+#    include _STLP_NATIVE_HEADER(limits)
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x39)
+#  include <stl/_epilog.h>
+#  undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_LIMITS */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/memory b/stlport/stlport/memory
new file mode 100644
index 0000000..3c0ceb3
--- /dev/null
+++ b/stlport/stlport/memory
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_MEMORY
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+#  define _STLP_OUTERMOST_HEADER_ID 0x46
+#  include <stl/_prolog.h>
+#  define _STLP_MEMORY
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x46)
+#  ifndef _STLP_INTERNAL_ALLOC_H
+#    include <stl/_alloc.h>
+#  endif
+
+#  ifndef _STLP_INTERNAL_TEMPBUF_H
+#    include <stl/_tempbuf.h>
+#  endif
+
+#  ifndef _STLP_INTERNAL_RAW_STORAGE_ITER_H
+#    include <stl/_raw_storage_iter.h>
+#  endif
+
+#  include <stl/_auto_ptr.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x46) || defined (_STLP_IMPORT_VENDOR_STD)
+#  if defined (__MSL__)
+#    include _STLP_NATIVE_HEADER(limits)
+#  endif
+
+#  if !defined(_STLP_NO_EXTENSIONS) && defined(_STLP_USE_BOOST_SUPPORT)
+#    define BOOST_TR1_MEMORY_INCLUDED
+#    define BOOST_TR1_FULL_MEMORY_INCLUDED
+#  endif
+
+#  if defined (_STLP_HAS_INCLUDE_NEXT)
+#    include_next <memory>
+#  else
+#    include _STLP_NATIVE_HEADER(memory)
+#  endif
+
+#  if defined (__MSL__) && (__MSL__ >= 0x2405   && __MSL__ < 0x5201) 
+/*  980401 vss  MSL 2.4  Pro 3 Release  */  
+#    include <new_mem.h>
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x46)
+#  include <stl/_epilog.h>
+#  undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#if !defined(_STLP_NO_EXTENSIONS) && defined(_STLP_USE_BOOST_SUPPORT)
+
+namespace boost {
+
+class bad_weak_ptr;
+template<class T> class shared_ptr;
+template<class T> class weak_ptr;
+template<class T> class enable_shared_from_this;
+template<class D, class T> D * get_deleter(shared_ptr<T> const & p);
+template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r);
+template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r);
+template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r);
+template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b);
+template<class T> void swap(shared_ptr<T> & a, shared_ptr<T> & b);
+
+namespace detail{
+class shared_count;
+class weak_count;
+}
+
+} // namespace boost
+
+#  ifndef BOOST_SHARED_PTR_HPP_INCLUDED
+#    include <boost/shared_ptr.hpp>
+#  endif
+#  ifndef BOOST_WEAK_PTR_HPP_INCLUDED
+#    include <boost/weak_ptr.hpp>
+#  endif
+#  ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
+#    include <boost/enable_shared_from_this.hpp>
+#  endif
+
+_STLP_BEGIN_NAMESPACE
+
+namespace tr1 {
+
+using ::boost::bad_weak_ptr;
+using ::boost::shared_ptr;
+using ::boost::swap;
+using ::boost::static_pointer_cast;
+using ::boost::dynamic_pointer_cast;
+using ::boost::const_pointer_cast;
+using ::boost::get_deleter;
+using ::boost::weak_ptr;
+using ::boost::enable_shared_from_this;
+
+// shared_ptr IO
+// weak_ptr IO
+
+} // namespace tr1
+
+_STLP_END_NAMESPACE
+
+#endif /* !_STLP_NO_EXTENSIONS && _STLP_USE_BOOST_SUPPORT */
+
+#endif /* _STLP_MEMORY */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/stlport/stlport/queue b/stlport/stlport/queue
new file mode 100644
index 0000000..6acd63f
--- /dev/null
+++ b/stlport/stlport/queue
@@ -0,0 +1,57 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_QUEUE
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+#  define _STLP_OUTERMOST_HEADER_ID 0x53
+#  include <stl/_prolog.h>
+#  define _STLP_QUEUE
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x53)
+#  ifndef _STLP_INTERNAL_QUEUE_H
+#    include <stl/_queue.h>
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x53) || defined (_STLP_IMPORT_VENDOR_STD)
+#  if defined (_STLP_HAS_INCLUDE_NEXT)
+#    include_next <queue>
+#  else
+#    include _STLP_NATIVE_HEADER(queue)
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x53)
+#  include <stl/_epilog.h>
+#  undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_QUEUE */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/slist b/stlport/stlport/slist
new file mode 100644
index 0000000..c1930e4
--- /dev/null
+++ b/stlport/stlport/slist
@@ -0,0 +1,54 @@
+/*
+ * 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 _STLP_SLIST
+#define _STLP_SLIST
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+#  define _STLP_OUTERMOST_HEADER_ID 0x58
+#  include <stl/_prolog.h>
+#endif
+
+#ifdef _STLP_PRAGMA_ONCE
+#  pragma once
+#endif
+
+#if defined (_STLP_NO_EXTENSIONS)
+/* Comment following if you want to use the slist constainer even if you ask for
+ * no extension.
+ */
+#  error The slist class is an STLport extension.
+#endif
+
+#ifndef _STLP_INTERNAL_SLIST_H
+#  include <stl/_slist.h>
+#endif
+
+#if defined (_STLP_IMPORT_VENDOR_STD)
+//This is not a Standard header, it might failed for most of
+//the compilers so we comment it for the moment. Should be uncommented
+//on a compiler basis.
+//#  include _STLP_NATIVE_HEADER(slist)
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x58)
+#  include <stl/_epilog.h>
+#  undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_SLIST */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stack b/stlport/stlport/stack
new file mode 100644
index 0000000..253b31d
--- /dev/null
+++ b/stlport/stlport/stack
@@ -0,0 +1,57 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_STACK
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+#  define _STLP_OUTERMOST_HEADER_ID 0x60
+#  include <stl/_prolog.h>
+#  define _STLP_STACK
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x60)
+#  ifndef _STLP_INTERNAL_STACK_H
+#    include <stl/_stack.h>
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x60) || defined (_STLP_IMPORT_VENDOR_STD)
+#  if defined (_STLP_HAS_INCLUDE_NEXT)
+#    include_next <stack>
+#  else
+#    include _STLP_NATIVE_HEADER(stack)
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x60)
+#  include <stl/_epilog.h>
+#  undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_STACK */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_algo.c b/stlport/stlport/stl/_algo.c
new file mode 100644
index 0000000..b58b92d
--- /dev/null
+++ b/stlport/stlport/stl/_algo.c
@@ -0,0 +1,2028 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_ALGO_C
+#define _STLP_ALGO_C
+
+#if !defined (_STLP_INTERNAL_ALGO_H)
+#  include <stl/_algo.h>
+#endif
+
+#ifndef _STLP_INTERNAL_TEMPBUF_H
+#  include <stl/_tempbuf.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _BidirectionalIter, class _Distance, class _Compare>
+void __merge_without_buffer(_BidirectionalIter __first,
+                            _BidirectionalIter __middle,
+                            _BidirectionalIter __last,
+                            _Distance __len1, _Distance __len2,
+                            _Compare __comp);
+
+
+template <class _BidirectionalIter1, class _BidirectionalIter2,
+          class _BidirectionalIter3, class _Compare>
+_BidirectionalIter3 __merge_backward(_BidirectionalIter1 __first1,
+                                     _BidirectionalIter1 __last1,
+                                     _BidirectionalIter2 __first2,
+                                     _BidirectionalIter2 __last2,
+                                     _BidirectionalIter3 __result,
+                                     _Compare __comp);
+
+template <class _Tp>
+#if !(defined (__SUNPRO_CC) && (__SUNPRO_CC < 0x420 ))
+inline
+#endif
+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>
+#if !(defined (__SUNPRO_CC) && (__SUNPRO_CC < 0x420 ))
+inline
+#endif
+const _Tp&
+__median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp) {
+  if (__comp(__a, __b)) {
+    _STLP_VERBOSE_ASSERT(!__comp(__b, __a), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+    if (__comp(__b, __c)) {
+      _STLP_VERBOSE_ASSERT(!__comp(__c, __b), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      return __b;
+    }
+    else if (__comp(__a, __c)) {
+      _STLP_VERBOSE_ASSERT(!__comp(__c, __a), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      return __c;
+    }
+    else
+      return __a;
+  }
+  else if (__comp(__a, __c)) {
+    _STLP_VERBOSE_ASSERT(!__comp(__c, __a), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+    return __a;
+  }
+  else if (__comp(__b, __c)) {
+    _STLP_VERBOSE_ASSERT(!__comp(__c, __b), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+    return __c;
+  }
+  else
+    return __b;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _ForwardIter1, class _ForwardIter2>
+_ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
+                     _ForwardIter2 __first2, _ForwardIter2 __last2) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+  // Test for empty ranges
+  if (__first1 == __last1 || __first2 == __last2)
+    return __first1;
+
+  // Test for a pattern of length 1.
+  _ForwardIter2 __p1(__first2);
+
+  if ( ++__p1 == __last2 )
+    return find(__first1, __last1, *__first2);
+
+  // General case.
+
+  for ( ; ; ) { // __first1 != __last1 will be checked in find below
+    __first1 = find(__first1, __last1, *__first2);
+    if (__first1 == __last1)
+      return __last1;
+
+    _ForwardIter2 __p = __p1;
+    _ForwardIter1 __current = __first1;
+    if (++__current == __last1)
+      return __last1;
+
+    while (*__current == *__p) {
+      if (++__p == __last2)
+        return __first1;
+      if (++__current == __last1)
+        return __last1;
+    }
+
+    ++__first1;
+  }
+  return __first1;
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _RandomAccessIter, class _Integer, class _Tp,
+          class _BinaryPred, class _Distance>
+_RandomAccessIter __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
+                             _Integer __count, const _Tp& __val, _BinaryPred __pred,
+                             _Distance*, const random_access_iterator_tag &)
+{
+  _Distance __tailSize = __last - __first;
+  const _Distance __pattSize = __count;
+  const _Distance __skipOffset = __pattSize - 1;
+  _RandomAccessIter __backTrack;
+  _Distance __remainder, __prevRemainder;
+
+  for ( _RandomAccessIter __lookAhead = __first + __skipOffset; __tailSize >= __pattSize; __lookAhead += __pattSize ) { // the main loop...
+    //__lookAhead here is always pointing to the last element of next possible match.
+    __tailSize -= __pattSize;
+
+    while ( !__pred(*__lookAhead, __val) ) { // the skip loop...
+      if (__tailSize < __pattSize)
+        return __last;
+
+      __lookAhead += __pattSize;
+      __tailSize -= __pattSize;
+    }
+
+    if ( __skipOffset == 0 ) {
+      return (__lookAhead - __skipOffset); //Success
+    }
+
+    __remainder = __skipOffset;
+
+    for (__backTrack = __lookAhead; __pred(*--__backTrack, __val); ) {
+      if (--__remainder == 0)
+        return (__lookAhead - __skipOffset); //Success
+    }
+
+    if (__remainder > __tailSize)
+      return __last; //failure
+
+    __lookAhead += __remainder;
+    __tailSize -= __remainder;
+
+    while ( __pred(*__lookAhead, __val) ) {
+      __prevRemainder = __remainder;
+      __backTrack = __lookAhead;
+
+      do {
+        if (--__remainder == 0)
+          return (__lookAhead - __skipOffset); //Success
+      } while (__pred(*--__backTrack, __val));
+
+      //adjust remainder for next comparison
+      __remainder += __pattSize - __prevRemainder;
+
+      if (__remainder > __tailSize)
+        return __last; //failure
+
+      __lookAhead += __remainder;
+      __tailSize -= __remainder;
+    }
+
+    //__lookAhead here is always pointing to the element of the last mismatch.
+  }
+
+  return __last; //failure
+}
+
+template <class _ForwardIter, class _Integer, class _Tp,
+          class _Distance, class _BinaryPred>
+_ForwardIter __search_n(_ForwardIter __first, _ForwardIter __last,
+                        _Integer __count, const _Tp& __val, _BinaryPred __pred,
+                        _Distance*, const forward_iterator_tag &) {
+  for (; (__first != __last) && !__pred(*__first, __val); ++__first) {}
+  while (__first != __last) {
+    _Integer __n = __count - 1;
+    _ForwardIter __i = __first;
+    ++__i;
+    while (__i != __last && __n != 0 && __pred(*__i, __val)) {
+      ++__i;
+      --__n;
+    }
+    if (__n == 0)
+      return __first;
+    else if (__i != __last)
+      for (__first = ++__i; (__first != __last) && !__pred(*__first, __val); ++__first) {}
+    else
+      break;
+  }
+  return __last;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+// 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) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  if (__count <= 0)
+    return __first;
+  if (__count == 1)
+    //We use find when __count == 1 to use potential find overload.
+    return find(__first, __last, __val);
+  return _STLP_PRIV __search_n(__first, __last, __count, __val, equal_to<_Tp>(),
+                               _STLP_DISTANCE_TYPE(__first, _ForwardIter),
+                               _STLP_ITERATOR_CATEGORY(__first, _ForwardIter));
+}
+
+template <class _ForwardIter, class _Integer, class _Tp, class _BinaryPred>
+_ForwardIter search_n(_ForwardIter __first, _ForwardIter __last,
+                      _Integer __count, const _Tp& __val,
+                      _BinaryPred __binary_pred) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  if (__count <= 0)
+    return __first;
+  return _STLP_PRIV __search_n(__first, __last, __count, __val, __binary_pred,
+                               _STLP_DISTANCE_TYPE(__first, _ForwardIter),
+                               _STLP_ITERATOR_CATEGORY(__first, _ForwardIter));
+}
+
+template <class _ForwardIter1, class _ForwardIter2>
+_ForwardIter1
+find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
+         _ForwardIter2 __first2, _ForwardIter2 __last2) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+  return _STLP_PRIV __find_end(__first1, __last1, __first2, __last2,
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+                               _STLP_ITERATOR_CATEGORY(__first1, _ForwardIter1),
+                               _STLP_ITERATOR_CATEGORY(__first2, _ForwardIter2),
+#else
+                               forward_iterator_tag(),
+                               forward_iterator_tag(),
+#endif
+                               _STLP_PRIV __equal_to(_STLP_VALUE_TYPE(__first1, _ForwardIter1))
+    );
+}
+
+// unique and unique_copy
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIterator, class _OutputIterator, class _BinaryPredicate,
+          class _Tp>
+_STLP_INLINE_LOOP _OutputIterator
+__unique_copy(_InputIterator __first, _InputIterator __last,
+              _OutputIterator __result,
+              _BinaryPredicate __binary_pred, _Tp*) {
+  _Tp __val = *__first;
+  *__result = __val;
+  while (++__first != __last)
+    if (!__binary_pred(__val, *__first)) {
+      __val = *__first;
+      *++__result = __val;
+    }
+  return ++__result;
+}
+
+template <class _InputIter, class _OutputIter, class _BinaryPredicate>
+inline _OutputIter
+__unique_copy(_InputIter __first, _InputIter __last,_OutputIter __result,
+              _BinaryPredicate __binary_pred, const output_iterator_tag &) {
+  return _STLP_PRIV __unique_copy(__first, __last, __result, __binary_pred,
+                                  _STLP_VALUE_TYPE(__first, _InputIter));
+}
+
+template <class _InputIter, class _ForwardIter, class _BinaryPredicate>
+_STLP_INLINE_LOOP _ForwardIter
+__unique_copy(_InputIter __first, _InputIter __last, _ForwardIter __result,
+              _BinaryPredicate __binary_pred, const forward_iterator_tag &) {
+  *__result = *__first;
+  while (++__first != __last)
+    if (!__binary_pred(*__result, *__first)) *++__result = *__first;
+  return ++__result;
+}
+
+#if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
+template <class _InputIterator, class _BidirectionalIterator, class _BinaryPredicate>
+inline _BidirectionalIterator
+__unique_copy(_InputIterator __first, _InputIterator __last,
+              _BidirectionalIterator __result, _BinaryPredicate __binary_pred,
+              const bidirectional_iterator_tag &) {
+  return _STLP_PRIV __unique_copy(__first, __last, __result, __binary_pred, forward_iterator_tag());
+}
+
+template <class _InputIterator, class _RandomAccessIterator, class _BinaryPredicate>
+inline _RandomAccessIterator
+__unique_copy(_InputIterator __first, _InputIterator __last,
+              _RandomAccessIterator __result, _BinaryPredicate __binary_pred,
+              const random_access_iterator_tag &) {
+  return _STLP_PRIV __unique_copy(__first, __last, __result, __binary_pred, forward_iterator_tag());
+}
+#endif /* _STLP_NONTEMPL_BASE_MATCH_BUG */
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter, class _OutputIter>
+_OutputIter
+unique_copy(_InputIter __first, _InputIter __last, _OutputIter __result) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  if (__first == __last) return __result;
+  return _STLP_PRIV __unique_copy(__first, __last, __result,
+                                  _STLP_PRIV __equal_to(_STLP_VALUE_TYPE(__first, _InputIter)),
+                                  _STLP_ITERATOR_CATEGORY(__result, _OutputIter));
+}
+
+template <class _InputIter, class _OutputIter, class _BinaryPredicate>
+_OutputIter
+unique_copy(_InputIter __first, _InputIter __last,_OutputIter __result,
+            _BinaryPredicate __binary_pred) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  if (__first == __last) return __result;
+  return _STLP_PRIV __unique_copy(__first, __last, __result, __binary_pred,
+                                  _STLP_ITERATOR_CATEGORY(__result, _OutputIter));
+}
+
+// rotate and rotate_copy, and their auxiliary functions
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _Distance>
+_ForwardIter __rotate_aux(_ForwardIter __first,
+                          _ForwardIter __middle,
+                          _ForwardIter __last,
+                          _Distance*,
+                          const forward_iterator_tag &) {
+  if (__first == __middle)
+    return __last;
+  if (__last  == __middle)
+    return __first;
+
+  _ForwardIter __first2 = __middle;
+  do {
+    _STLP_STD::swap(*__first++, *__first2++);
+    if (__first == __middle)
+      __middle = __first2;
+  } while (__first2 != __last);
+
+  _ForwardIter __new_middle = __first;
+
+  __first2 = __middle;
+
+  while (__first2 != __last) {
+    _STLP_STD::swap (*__first++, *__first2++);
+    if (__first == __middle)
+      __middle = __first2;
+    else if (__first2 == __last)
+      __first2 = __middle;
+  }
+
+  return __new_middle;
+}
+
+template <class _BidirectionalIter, class _Distance>
+_BidirectionalIter __rotate_aux(_BidirectionalIter __first,
+                                _BidirectionalIter __middle,
+                                _BidirectionalIter __last,
+                                _Distance*,
+                                const bidirectional_iterator_tag &) {
+  if (__first == __middle)
+    return __last;
+  if (__last  == __middle)
+    return __first;
+
+  _STLP_PRIV __reverse(__first,  __middle, bidirectional_iterator_tag());
+  _STLP_PRIV __reverse(__middle, __last,   bidirectional_iterator_tag());
+
+  while (__first != __middle && __middle != __last)
+    _STLP_STD::swap(*__first++, *--__last);
+
+  if (__first == __middle) {
+    _STLP_PRIV __reverse(__middle, __last,   bidirectional_iterator_tag());
+    return __last;
+  }
+  else {
+    _STLP_PRIV __reverse(__first,  __middle, bidirectional_iterator_tag());
+    return __first;
+  }
+}
+
+// rotate and rotate_copy, and their auxiliary functions
+template <class _EuclideanRingElement>
+_STLP_INLINE_LOOP
+_EuclideanRingElement __gcd(_EuclideanRingElement __m,
+                            _EuclideanRingElement __n) {
+  while (__n != 0) {
+    _EuclideanRingElement __t = __m % __n;
+    __m = __n;
+    __n = __t;
+  }
+  return __m;
+}
+
+template <class _RandomAccessIter, class _Distance, class _Tp>
+_RandomAccessIter __rotate_aux(_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 == 0)  /* __first == middle */
+    return __last;
+
+  if (__k == __l) {
+    _STLP_STD::swap_ranges(__first, __middle, __middle);
+    return __result;
+  }
+
+  _Distance __d = _STLP_PRIV __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 _RandomAccessIter, class _Distance>
+inline _RandomAccessIter
+__rotate_aux(_RandomAccessIter __first, _RandomAccessIter __middle, _RandomAccessIter __last,
+             _Distance * __dis, const random_access_iterator_tag &) {
+  return _STLP_PRIV __rotate_aux(__first, __middle, __last,
+                                 __dis, _STLP_VALUE_TYPE(__first, _RandomAccessIter));
+}
+
+template <class _ForwardIter>
+_ForwardIter
+__rotate(_ForwardIter __first, _ForwardIter __middle, _ForwardIter __last) {
+  _STLP_DEBUG_CHECK(__check_range(__first, __middle))
+  _STLP_DEBUG_CHECK(__check_range(__middle, __last))
+  return __rotate_aux(__first, __middle, __last,
+                      _STLP_DISTANCE_TYPE(__first, _ForwardIter),
+                      _STLP_ITERATOR_CATEGORY(__first, _ForwardIter));
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _ForwardIter>
+void rotate(_ForwardIter __first, _ForwardIter __middle, _ForwardIter __last) {
+  _STLP_PRIV __rotate(__first, __middle, __last);
+}
+
+// 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).
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Distance>
+inline _Distance __random_number(_Distance __n) {
+#ifdef _STLP_NO_DRAND48
+  return rand() % __n;
+#else
+  return lrand48() % __n;
+#endif
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _RandomAccessIter>
+void random_shuffle(_RandomAccessIter __first,
+                    _RandomAccessIter __last) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  if (__first == __last) return;
+  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
+    iter_swap(__i, __first + _STLP_PRIV __random_number((__i - __first) + 1));
+}
+
+template <class _RandomAccessIter, class _RandomNumberGenerator>
+void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last,
+                    _RandomNumberGenerator &__rand) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  if (__first == __last) return;
+  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
+    iter_swap(__i, __first + __rand((__i - __first) + 1));
+}
+
+#if !defined (_STLP_NO_EXTENSIONS)
+// 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_ite, const _Distance __n) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  _Distance __remaining = _STLP_STD::distance(__first, __last);
+  _Distance __m = (min) (__n, __remaining);
+
+  while (__m > 0) {
+    if (_STLP_PRIV __random_number(__remaining) < __m) {
+      *__out_ite = *__first;
+      ++__out_ite;
+      --__m;
+    }
+
+    --__remaining;
+    ++__first;
+  }
+  return __out_ite;
+}
+
+
+template <class _ForwardIter, class _OutputIter, class _Distance,
+          class _RandomNumberGenerator>
+_OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last,
+                            _OutputIter __out_ite, const _Distance __n,
+                            _RandomNumberGenerator& __rand) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  _Distance __remaining = _STLP_STD::distance(__first, __last);
+  _Distance __m = (min) (__n, __remaining);
+
+  while (__m > 0) {
+    if (__rand(__remaining) < __m) {
+      *__out_ite = *__first;
+      ++__out_ite;
+      --__m;
+    }
+
+    --__remaining;
+    ++__first;
+  }
+  return __out_ite;
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter, class _RandomAccessIter, class _Distance>
+_RandomAccessIter __random_sample(_InputIter __first, _InputIter __last,
+                                  _RandomAccessIter __out_ite,
+                                  const _Distance __n) {
+  _Distance __m = 0;
+  _Distance __t = __n;
+  for ( ; __first != __last && __m < __n; ++__m, ++__first)
+    __out_ite[__m] = *__first;
+
+  while (__first != __last) {
+    ++__t;
+    _Distance __M = __random_number(__t);
+    if (__M < __n)
+      __out_ite[__M] = *__first;
+    ++__first;
+  }
+
+  return __out_ite + __m;
+}
+
+template <class _InputIter, class _RandomAccessIter,
+          class _RandomNumberGenerator, class _Distance>
+_RandomAccessIter __random_sample(_InputIter __first, _InputIter __last,
+                                  _RandomAccessIter __out_ite,
+                                  _RandomNumberGenerator& __rand,
+                                  const _Distance __n) {
+  _Distance __m = 0;
+  _Distance __t = __n;
+  for ( ; __first != __last && __m < __n; ++__m, ++__first)
+    __out_ite[__m] = *__first;
+
+  while (__first != __last) {
+    ++__t;
+    _Distance __M = __rand(__t);
+    if (__M < __n)
+      __out_ite[__M] = *__first;
+    ++__first;
+  }
+
+  return __out_ite + __m;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter, class _RandomAccessIter>
+_RandomAccessIter
+random_sample(_InputIter __first, _InputIter __last,
+              _RandomAccessIter __out_first, _RandomAccessIter __out_last) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__out_first, __out_last))
+  return _STLP_PRIV __random_sample(__first, __last,
+                                    __out_first, __out_last - __out_first);
+}
+
+template <class _InputIter, class _RandomAccessIter, class _RandomNumberGenerator>
+_RandomAccessIter
+random_sample(_InputIter __first, _InputIter __last,
+              _RandomAccessIter __out_first, _RandomAccessIter __out_last,
+              _RandomNumberGenerator& __rand) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__out_first, __out_last))
+  return _STLP_PRIV __random_sample(__first, __last,
+                                    __out_first, __rand,
+                                    __out_last - __out_first);
+}
+
+#endif /* _STLP_NO_EXTENSIONS */
+
+// partition, stable_partition, and their auxiliary functions
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _Predicate>
+_STLP_INLINE_LOOP _ForwardIter __partition(_ForwardIter __first,
+                                           _ForwardIter __last,
+                                           _Predicate   __pred,
+                                           const 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)) {
+      _STLP_STD::swap(*__first, *__next);
+      ++__first;
+    }
+  }
+  return __first;
+}
+
+template <class _BidirectionalIter, class _Predicate>
+_STLP_INLINE_LOOP _BidirectionalIter __partition(_BidirectionalIter __first,
+                                                 _BidirectionalIter __last,
+                                                 _Predicate __pred,
+                                                 const bidirectional_iterator_tag &) {
+  for (;;) {
+    for (;;) {
+      if (__first == __last)
+        return __first;
+      else if (__pred(*__first))
+        ++__first;
+      else
+        break;
+    }
+    --__last;
+    for (;;) {
+      if (__first == __last)
+        return __first;
+      else if (!__pred(*__last))
+        --__last;
+      else
+        break;
+    }
+    iter_swap(__first, __last);
+    ++__first;
+  }
+}
+
+#if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
+template <class _BidirectionalIter, class _Predicate>
+inline
+_BidirectionalIter __partition(_BidirectionalIter __first,
+                               _BidirectionalIter __last,
+                               _Predicate __pred,
+                               const random_access_iterator_tag &) {
+  return __partition(__first, __last, __pred, bidirectional_iterator_tag());
+}
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _ForwardIter, class _Predicate>
+_ForwardIter partition(_ForwardIter __first, _ForwardIter __last, _Predicate   __pred) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  return _STLP_PRIV __partition(__first, __last, __pred, _STLP_ITERATOR_CATEGORY(__first, _ForwardIter));
+}
+
+
+/* __pred_of_first: false if we know that __pred(*__first) is false,
+ *                  true when we don't know the result of __pred(*__first).
+ * __not_pred_of_before_last: true if we know that __pred(*--__last) is true,
+ *                            false when we don't know the result of __pred(*--__last).
+ */
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _Predicate, class _Distance>
+_ForwardIter __inplace_stable_partition(_ForwardIter __first,
+                                        _ForwardIter __last,
+                                        _Predicate __pred, _Distance __len,
+                                        bool __pred_of_first, bool __pred_of_before_last) {
+  if (__len == 1)
+    return (__pred_of_first && (__pred_of_before_last || __pred(*__first))) ? __last : __first;
+  _ForwardIter __middle = __first;
+  _Distance __half_len = __len / 2;
+  _STLP_STD::advance(__middle, __half_len);
+  return _STLP_PRIV __rotate(_STLP_PRIV __inplace_stable_partition(__first, __middle, __pred, __half_len, __pred_of_first, false),
+                             __middle,
+                             _STLP_PRIV __inplace_stable_partition(__middle, __last, __pred, __len - __half_len, true, __pred_of_before_last));
+}
+
+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,
+                                         bool __pred_of_first, bool __pred_of_before_last) {
+  if (__len <= __buffer_size) {
+    _ForwardIter __result1 = __first;
+    _Pointer __result2 = __buffer;
+    if ((__first != __last) && (!__pred_of_first || __pred(*__first))) {
+      *__result2 = *__first;
+      ++__result2; ++__first; --__len;
+    }
+    for (; __first != __last ; ++__first, --__len) {
+      if (((__len == 1) && (__pred_of_before_last || __pred(*__first))) ||
+          ((__len != 1) && __pred(*__first))){
+        *__result1 = *__first;
+        ++__result1;
+      }
+      else {
+        *__result2 = *__first;
+        ++__result2;
+      }
+    }
+    _STLP_STD::copy(__buffer, __result2, __result1);
+    return __result1;
+  }
+  else {
+    _ForwardIter __middle = __first;
+    _Distance __half_len = __len / 2;
+    _STLP_STD::advance(__middle, __half_len);
+    return _STLP_PRIV __rotate(_STLP_PRIV __stable_partition_adaptive(__first, __middle, __pred,
+                                                                      __half_len, __buffer, __buffer_size,
+                                                                      __pred_of_first, false),
+                               __middle,
+                               _STLP_PRIV __stable_partition_adaptive(__middle, __last, __pred,
+                                                                      __len - __half_len, __buffer, __buffer_size,
+                                                                      true, __pred_of_before_last));
+  }
+}
+
+template <class _ForwardIter, class _Predicate, class _Tp, class _Distance>
+inline _ForwardIter
+__stable_partition_aux_aux(_ForwardIter __first, _ForwardIter __last,
+                           _Predicate __pred, _Tp*, _Distance*, bool __pred_of_before_last) {
+  _Temporary_buffer<_ForwardIter, _Tp> __buf(__first, __last);
+  _STLP_MPWFIX_TRY    //*TY 06/01/2000 - they forget to call dtor for _Temporary_buffer if no try/catch block is present
+  return (__buf.size() > 0) ?
+    __stable_partition_adaptive(__first, __last, __pred,
+                                _Distance(__buf.requested_size()),
+                                __buf.begin(), __buf.size(),
+                                false, __pred_of_before_last)  :
+    __inplace_stable_partition(__first, __last, __pred,
+                               _Distance(__buf.requested_size()),
+                               false, __pred_of_before_last);
+  _STLP_MPWFIX_CATCH  //*TY 06/01/2000 - they forget to call dtor for _Temporary_buffer if no try/catch block is present
+}
+
+template <class _ForwardIter, class _Predicate>
+_ForwardIter
+__stable_partition_aux(_ForwardIter __first, _ForwardIter __last, _Predicate __pred,
+                       const forward_iterator_tag &) {
+  return __stable_partition_aux_aux(__first, __last, __pred,
+                                    _STLP_VALUE_TYPE(__first, _ForwardIter),
+                                    _STLP_DISTANCE_TYPE(__first, _ForwardIter), false);
+}
+
+template <class _BidirectIter, class _Predicate>
+_BidirectIter
+__stable_partition_aux(_BidirectIter __first, _BidirectIter __last, _Predicate __pred,
+                       const bidirectional_iterator_tag &) {
+  for (--__last;;) {
+    if (__first == __last)
+      return __first;
+    else if (!__pred(*__last))
+      --__last;
+    else
+      break;
+  }
+  ++__last;
+  //Here we know that __pred(*--__last) is true
+  return __stable_partition_aux_aux(__first, __last, __pred,
+                                    _STLP_VALUE_TYPE(__first, _BidirectIter),
+                                    _STLP_DISTANCE_TYPE(__first, _BidirectIter), true);
+}
+
+#if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
+template <class _BidirectIter, class _Predicate>
+_BidirectIter
+__stable_partition_aux(_BidirectIter __first, _BidirectIter __last, _Predicate __pred,
+                       const random_access_iterator_tag &) {
+  return __stable_partition_aux(__first, __last, __pred, bidirectional_iterator_tag());
+}
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _ForwardIter, class _Predicate>
+_ForwardIter
+stable_partition(_ForwardIter __first, _ForwardIter __last, _Predicate __pred) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  for (;;) {
+    if (__first == __last)
+      return __first;
+    else if (__pred(*__first))
+      ++__first;
+    else
+      break;
+  }
+  return _STLP_PRIV __stable_partition_aux(__first, __last, __pred,
+                                           _STLP_ITERATOR_CATEGORY(__first, _ForwardIter));
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _RandomAccessIter, class _Tp, class _Compare>
+_RandomAccessIter __unguarded_partition(_RandomAccessIter __first,
+                                        _RandomAccessIter __last,
+                                        _Tp __pivot, _Compare __comp) {
+  for (;;) {
+    while (__comp(*__first, __pivot)) {
+      _STLP_VERBOSE_ASSERT(!__comp(__pivot, *__first), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      ++__first;
+    }
+    --__last;
+    while (__comp(__pivot, *__last)) {
+      _STLP_VERBOSE_ASSERT(!__comp(*__last, __pivot), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      --__last;
+    }
+    if (!(__first < __last))
+      return __first;
+    iter_swap(__first, __last);
+    ++__first;
+  }
+}
+
+// sort() and its auxiliary functions.
+#define __stl_threshold  16
+
+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)) {
+    _STLP_VERBOSE_ASSERT(!__comp(*__next, __val), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+    *__last = *__next;
+    __last = __next;
+    --__next;
+  }
+  *__last = __val;
+}
+
+template <class _RandomAccessIter, class _Tp, class _Compare>
+inline void __linear_insert(_RandomAccessIter __first,
+                            _RandomAccessIter __last, _Tp __val, _Compare __comp) {
+  //*TY 12/26/1998 - added __val as a paramter
+  //  _Tp __val = *__last;        //*TY 12/26/1998 - __val supplied by caller
+  if (__comp(__val, *__first)) {
+    _STLP_VERBOSE_ASSERT(!__comp(*__first, __val), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+    copy_backward(__first, __last, __last + 1);
+    *__first = __val;
+  }
+  else
+    __unguarded_linear_insert(__last, __val, __comp);
+}
+
+template <class _RandomAccessIter, class _Tp, class _Compare>
+void __insertion_sort(_RandomAccessIter __first,
+                      _RandomAccessIter __last,
+                      _Tp *, _Compare __comp) {
+  if (__first == __last) return;
+  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
+    __linear_insert<_RandomAccessIter, _Tp, _Compare>(__first, __i, *__i, __comp);  //*TY 12/26/1998 - supply *__i as __val
+}
+
+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<_RandomAccessIter, _Tp, _Compare>(__i, *__i, __comp);
+}
+
+template <class _RandomAccessIter, class _Compare>
+inline void __unguarded_insertion_sort(_RandomAccessIter __first,
+                                       _RandomAccessIter __last,
+                                       _Compare __comp) {
+  __unguarded_insertion_sort_aux(__first, __last, _STLP_VALUE_TYPE(__first, _RandomAccessIter), __comp);
+}
+
+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, _STLP_VALUE_TYPE(__first,_RandomAccessIter), __comp);
+    __unguarded_insertion_sort(__first + __stl_threshold, __last, __comp);
+  }
+  else
+    __insertion_sort(__first, __last, _STLP_VALUE_TYPE(__first,_RandomAccessIter), __comp);
+}
+
+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;
+  }
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _RandomAccessIter>
+void sort(_RandomAccessIter __first, _RandomAccessIter __last) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  if (__first != __last) {
+    _STLP_PRIV __introsort_loop(__first, __last,
+                                _STLP_VALUE_TYPE(__first, _RandomAccessIter),
+                                _STLP_PRIV __lg(__last - __first) * 2,
+                                _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _RandomAccessIter)));
+    _STLP_PRIV __final_insertion_sort(__first, __last,
+                                      _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _RandomAccessIter)));
+  }
+}
+
+template <class _RandomAccessIter, class _Compare>
+void sort(_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  if (__first != __last) {
+    _STLP_PRIV __introsort_loop(__first, __last,
+                                _STLP_VALUE_TYPE(__first, _RandomAccessIter),
+                                _STLP_PRIV __lg(__last - __first) * 2, __comp);
+    _STLP_PRIV __final_insertion_sort(__first, __last, __comp);
+  }
+}
+
+// stable_sort() and its auxiliary functions.
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _RandomAccessIter, class _Compare>
+void __inplace_stable_sort(_RandomAccessIter __first,
+                           _RandomAccessIter __last, _Compare __comp) {
+  if (__last - __first < 15) {
+    __insertion_sort(__first, __last, _STLP_VALUE_TYPE(__first,_RandomAccessIter), __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, 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, 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,
+                     _STLP_VALUE_TYPE(__first,_RandomAccessIter), __comp);
+    __first += __chunk_size;
+  }
+  __insertion_sort(__first, __last, _STLP_VALUE_TYPE(__first,_RandomAccessIter), __comp);
+}
+
+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 _BidirectionalIter1, class _BidirectionalIter2,
+          class _Distance>
+_BidirectionalIter1 __rotate_adaptive(_BidirectionalIter1 __first,
+                                      _BidirectionalIter1 __middle,
+                                      _BidirectionalIter1 __last,
+                                      _Distance __len1, _Distance __len2,
+                                      _BidirectionalIter2 __buffer,
+                                      _Distance __buffer_size) {
+  if (__len1 > __len2 && __len2 <= __buffer_size) {
+    _BidirectionalIter2 __buffer_end = _STLP_STD::copy(__middle, __last, __buffer);
+    _STLP_STD::copy_backward(__first, __middle, __last);
+    return _STLP_STD::copy(__buffer, __buffer_end, __first);
+  }
+  else if (__len1 <= __buffer_size) {
+    _BidirectionalIter2 __buffer_end = _STLP_STD::copy(__first, __middle, __buffer);
+    _STLP_STD::copy(__middle, __last, __first);
+    return _STLP_STD::copy_backward(__buffer, __buffer_end, __last);
+  }
+  else
+    return _STLP_PRIV __rotate(__first, __middle, __last);
+}
+
+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 = _STLP_STD::copy(__first, __middle, __buffer);
+    _STLP_STD::merge(__buffer, __buffer_end, __middle, __last, __first, __comp);
+  }
+  else if (__len2 <= __buffer_size) {
+    _Pointer __buffer_end = _STLP_STD::copy(__middle, __last, __buffer);
+    _STLP_PRIV __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;
+      _STLP_STD::advance(__first_cut, __len11);
+      __second_cut = _STLP_STD::lower_bound(__middle, __last, *__first_cut, __comp);
+      __len22 += _STLP_STD::distance(__middle, __second_cut);
+    }
+    else {
+      __len22 = __len2 / 2;
+      _STLP_STD::advance(__second_cut, __len22);
+      __first_cut = _STLP_STD::upper_bound(__first, __middle, *__second_cut, __comp);
+      __len11 += _STLP_STD::distance(__first, __first_cut);
+    }
+    _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 _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, class _Compare>
+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);
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _RandomAccessIter>
+void stable_sort(_RandomAccessIter __first,
+                 _RandomAccessIter __last) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  _STLP_PRIV __stable_sort_aux(__first, __last,
+                               _STLP_VALUE_TYPE(__first, _RandomAccessIter),
+                               _STLP_DISTANCE_TYPE(__first, _RandomAccessIter),
+                               _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _RandomAccessIter)));
+}
+
+template <class _RandomAccessIter, class _Compare>
+void stable_sort(_RandomAccessIter __first,
+                 _RandomAccessIter __last, _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  _STLP_PRIV __stable_sort_aux(__first, __last,
+                               _STLP_VALUE_TYPE(__first, _RandomAccessIter),
+                               _STLP_DISTANCE_TYPE(__first, _RandomAccessIter),
+                               __comp);
+}
+
+// partial_sort, partial_sort_copy, and auxiliary functions.
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+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)) {
+      _STLP_VERBOSE_ASSERT(!__comp(*__first, *__i), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      __pop_heap(__first, __middle, __i, _Tp(*__i), __comp,
+                 _STLP_DISTANCE_TYPE(__first, _RandomAccessIter));
+    }
+  }
+  sort_heap(__first, __middle, __comp);
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _RandomAccessIter>
+void partial_sort(_RandomAccessIter __first,_RandomAccessIter __middle,
+                  _RandomAccessIter __last) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __middle))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__middle, __last))
+  _STLP_PRIV __partial_sort(__first, __middle, __last, _STLP_VALUE_TYPE(__first, _RandomAccessIter),
+                            _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _RandomAccessIter)));
+}
+
+template <class _RandomAccessIter, class _Compare>
+void partial_sort(_RandomAccessIter __first,_RandomAccessIter __middle,
+                  _RandomAccessIter __last, _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __middle))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__middle, __last))
+  _STLP_PRIV __partial_sort(__first, __middle, __last, _STLP_VALUE_TYPE(__first, _RandomAccessIter), __comp);
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+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)) {
+      _STLP_VERBOSE_ASSERT(!__comp(*__result_first, *__first), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      __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;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter, class _RandomAccessIter>
+_RandomAccessIter
+partial_sort_copy(_InputIter __first, _InputIter __last,
+                  _RandomAccessIter __result_first, _RandomAccessIter __result_last) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__result_first, __result_last))
+  return _STLP_PRIV __partial_sort_copy(__first, __last, __result_first, __result_last,
+                                        _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _InputIter)),
+                                        _STLP_DISTANCE_TYPE(__result_first, _RandomAccessIter),
+                                        _STLP_VALUE_TYPE(__first, _InputIter));
+}
+
+template <class _InputIter, class _RandomAccessIter, class _Compare>
+_RandomAccessIter
+partial_sort_copy(_InputIter __first, _InputIter __last,
+                  _RandomAccessIter __result_first,
+                  _RandomAccessIter __result_last, _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__result_first, __result_last))
+  return _STLP_PRIV __partial_sort_copy(__first, __last, __result_first, __result_last,
+                                        __comp,
+                                        _STLP_DISTANCE_TYPE(__result_first, _RandomAccessIter),
+                                        _STLP_VALUE_TYPE(__first, _InputIter));
+}
+
+// nth_element() and its auxiliary functions.
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+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, _STLP_VALUE_TYPE(__first,_RandomAccessIter), __comp);
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _RandomAccessIter>
+void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
+                 _RandomAccessIter __last) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __nth))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__nth, __last))
+  _STLP_PRIV __nth_element(__first, __nth, __last, _STLP_VALUE_TYPE(__first, _RandomAccessIter),
+                           _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _RandomAccessIter)));
+}
+
+template <class _RandomAccessIter, class _Compare>
+void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
+                 _RandomAccessIter __last, _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __nth))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__nth, __last))
+  _STLP_PRIV __nth_element(__first, __nth, __last, _STLP_VALUE_TYPE(__first, _RandomAccessIter), __comp);
+}
+
+// Binary search (lower_bound, upper_bound, equal_range, binary_search).
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _Tp,
+          class _Compare1, class _Compare2, class _Distance>
+_ForwardIter __upper_bound(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+                           _Compare1 __comp1, _Compare2 __comp2, _Distance*) {
+  _Distance __len = _STLP_STD::distance(__first, __last);
+  _Distance __half;
+
+  while (__len > 0) {
+    __half = __len >> 1;
+    _ForwardIter __middle = __first;
+    _STLP_STD::advance(__middle, __half);
+    if (__comp2(__val, *__middle)) {
+      _STLP_VERBOSE_ASSERT(!__comp1(*__middle, __val), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      __len = __half;
+    }
+    else {
+      __first = __middle;
+      ++__first;
+      __len = __len - __half - 1;
+    }
+  }
+  return __first;
+}
+
+template <class _ForwardIter, class _Tp,
+          class _Compare1, class _Compare2, class _Distance>
+pair<_ForwardIter, _ForwardIter>
+__equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+              _Compare1 __comp1, _Compare2 __comp2, _Distance* __dist) {
+  _Distance __len = _STLP_STD::distance(__first, __last);
+  _Distance __half;
+
+  while (__len > 0) {
+    __half = __len >> 1;
+    _ForwardIter __middle = __first;
+    _STLP_STD::advance(__middle, __half);
+    if (__comp1(*__middle, __val)) {
+      _STLP_VERBOSE_ASSERT(!__comp2(__val, *__middle), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      __first = __middle;
+      ++__first;
+      __len = __len - __half - 1;
+    }
+    else if (__comp2(__val, *__middle)) {
+      _STLP_VERBOSE_ASSERT(!__comp1(*__middle, __val), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      __len = __half;
+    }
+    else {
+      _ForwardIter __left = _STLP_PRIV __lower_bound(__first, __middle, __val, __comp1, __comp2, __dist);
+      //Small optim: If lower_bound haven't found an equivalent value
+      //there is no need to call upper_bound.
+      if (__comp1(*__left, __val)) {
+        _STLP_VERBOSE_ASSERT(!__comp2(__val, *__left), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+        return pair<_ForwardIter, _ForwardIter>(__left, __left);
+      }
+      _STLP_STD::advance(__first, __len);
+      _ForwardIter __right = _STLP_PRIV __upper_bound(++__middle, __first, __val, __comp1, __comp2, __dist);
+      return pair<_ForwardIter, _ForwardIter>(__left, __right);
+    }
+  }
+  return pair<_ForwardIter, _ForwardIter>(__first, __first);
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,
+                  _InputIter2 __first2, _InputIter2 __last2,
+                  _OutputIter __result) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+  while (__first1 != __last1 && __first2 != __last2) {
+    if (*__first2 < *__first1) {
+      *__result = *__first2;
+      ++__first2;
+    }
+    else {
+      *__result = *__first1;
+      ++__first1;
+    }
+    ++__result;
+  }
+  return _STLP_STD::copy(__first2, __last2, _STLP_STD::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) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+  while (__first1 != __last1 && __first2 != __last2) {
+    if (__comp(*__first2, *__first1)) {
+      _STLP_VERBOSE_ASSERT(!__comp(*__first1, *__first2), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      *__result = *__first2;
+      ++__first2;
+    }
+    else {
+      *__result = *__first1;
+      ++__first1;
+    }
+    ++__result;
+  }
+  return _STLP_STD::copy(__first2, __last2, _STLP_STD::copy(__first1, __last1, __result));
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+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)) {
+      _STLP_VERBOSE_ASSERT(!__comp(*__first, *__middle), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      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;
+    _STLP_STD::advance(__first_cut, __len11);
+    __second_cut = _STLP_STD::lower_bound(__middle, __last, *__first_cut, __comp);
+    __len22 += _STLP_STD::distance(__middle, __second_cut);
+  }
+  else {
+    __len22 = __len2 / 2;
+    _STLP_STD::advance(__second_cut, __len22);
+    __first_cut = _STLP_STD::upper_bound(__first, __middle, *__second_cut, __comp);
+    __len11 += _STLP_STD::distance(__first, __first_cut);
+  }
+  _BidirectionalIter __new_middle
+    = _STLP_PRIV __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 _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;
+  for (;;) {
+    if (__comp(*__last2, *__last1)) {
+      _STLP_VERBOSE_ASSERT(!__comp(*__last1, *__last2), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      *--__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 _Tp,
+          class _Distance, class _Compare>
+inline void __inplace_merge_aux(_BidirectionalIter __first,
+                                _BidirectionalIter __middle,
+                                _BidirectionalIter __last, _Tp*, _Distance*,
+                                _Compare __comp) {
+  _Distance __len1 = _STLP_STD::distance(__first, __middle);
+  _Distance __len2 = _STLP_STD::distance(__middle, __last);
+
+  _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);
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _BidirectionalIter>
+void inplace_merge(_BidirectionalIter __first,
+                   _BidirectionalIter __middle,
+                   _BidirectionalIter __last) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __middle))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__middle, __last))
+  if (__first == __middle || __middle == __last)
+    return;
+  _STLP_PRIV __inplace_merge_aux(__first, __middle, __last,
+                                 _STLP_VALUE_TYPE(__first, _BidirectionalIter), _STLP_DISTANCE_TYPE(__first, _BidirectionalIter),
+                                 _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _BidirectionalIter)));
+}
+
+template <class _BidirectionalIter, class _Compare>
+void inplace_merge(_BidirectionalIter __first,
+                   _BidirectionalIter __middle,
+                   _BidirectionalIter __last, _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __middle))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__middle, __last))
+  if (__first == __middle || __middle == __last)
+    return;
+  _STLP_PRIV __inplace_merge_aux(__first, __middle, __last,
+                                 _STLP_VALUE_TYPE(__first, _BidirectionalIter), _STLP_DISTANCE_TYPE(__first, _BidirectionalIter),
+                                 __comp);
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _Compare>
+bool __includes(_InputIter1 __first1, _InputIter1 __last1,
+                _InputIter2 __first2, _InputIter2 __last2, _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+  while (__first1 != __last1 && __first2 != __last2)
+    if (__comp(*__first2, *__first1)) {
+      _STLP_VERBOSE_ASSERT(!__comp(*__first1, *__first2), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      return false;
+    }
+    else if (__comp(*__first1, *__first2))
+      ++__first1;
+    else
+      ++__first1, ++__first2;
+
+  return __first2 == __last2;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _Compare>
+bool includes(_InputIter1 __first1, _InputIter1 __last1,
+              _InputIter2 __first2, _InputIter2 __last2, _Compare __comp) {
+  return _STLP_PRIV __includes(__first1, __last1, __first2, __last2, __comp);
+}
+
+template <class _InputIter1, class _InputIter2>
+bool includes(_InputIter1 __first1, _InputIter1 __last1,
+              _InputIter2 __first2, _InputIter2 __last2) {
+  return _STLP_PRIV __includes(__first1, __last1, __first2, __last2,
+                               _STLP_PRIV __less(_STLP_VALUE_TYPE(__first1, _InputIter1)));
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+          class _Compare>
+_OutputIter __set_union(_InputIter1 __first1, _InputIter1 __last1,
+                        _InputIter2 __first2, _InputIter2 __last2,
+                        _OutputIter __result, _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+  while (__first1 != __last1 && __first2 != __last2) {
+    if (__comp(*__first1, *__first2)) {
+      _STLP_VERBOSE_ASSERT(!__comp(*__first2, *__first1), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      *__result = *__first1;
+      ++__first1;
+    }
+    else if (__comp(*__first2, *__first1)) {
+      _STLP_VERBOSE_ASSERT(!__comp(*__first1, *__first2), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      *__result = *__first2;
+      ++__first2;
+    }
+    else {
+      *__result = *__first1;
+      ++__first1;
+      ++__first2;
+    }
+    ++__result;
+  }
+  return _STLP_STD::copy(__first2, __last2, _STLP_STD::copy(__first1, __last1, __result));
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
+                      _InputIter2 __first2, _InputIter2 __last2,
+                      _OutputIter __result) {
+  return _STLP_PRIV __set_union(__first1, __last1, __first2, __last2, __result,
+                                _STLP_PRIV __less(_STLP_VALUE_TYPE(__first1, _InputIter1)));
+}
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+          class _Compare>
+_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
+                      _InputIter2 __first2, _InputIter2 __last2,
+                      _OutputIter __result, _Compare __comp) {
+  return _STLP_PRIV __set_union(__first1, __last1, __first2, __last2, __result, __comp);
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+          class _Compare>
+_OutputIter __set_intersection(_InputIter1 __first1, _InputIter1 __last1,
+                               _InputIter2 __first2, _InputIter2 __last2,
+                               _OutputIter __result, _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+  while (__first1 != __last1 && __first2 != __last2)
+    if (__comp(*__first1, *__first2)) {
+      _STLP_VERBOSE_ASSERT(!__comp(*__first2, *__first1), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      ++__first1;
+    }
+    else if (__comp(*__first2, *__first1))
+      ++__first2;
+    else {
+      *__result = *__first1;
+      ++__first1;
+      ++__first2;
+      ++__result;
+    }
+  return __result;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
+                             _InputIter2 __first2, _InputIter2 __last2,
+                             _OutputIter __result) {
+  return _STLP_PRIV __set_intersection(__first1, __last1, __first2, __last2, __result,
+                                       _STLP_PRIV __less(_STLP_VALUE_TYPE(__first1, _InputIter1)));
+}
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+          class _Compare>
+_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
+                             _InputIter2 __first2, _InputIter2 __last2,
+                             _OutputIter __result, _Compare __comp) {
+  return _STLP_PRIV __set_intersection(__first1, __last1, __first2, __last2, __result, __comp);
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+          class _Compare>
+_OutputIter __set_difference(_InputIter1 __first1, _InputIter1 __last1,
+                             _InputIter2 __first2, _InputIter2 __last2,
+                             _OutputIter __result, _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+  while (__first1 != __last1 && __first2 != __last2)
+    if (__comp(*__first1, *__first2)) {
+      _STLP_VERBOSE_ASSERT(!__comp(*__first2, *__first1), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      *__result = *__first1;
+      ++__first1;
+      ++__result;
+    }
+    else if (__comp(*__first2, *__first1))
+      ++__first2;
+    else {
+      ++__first1;
+      ++__first2;
+    }
+  return _STLP_STD::copy(__first1, __last1, __result);
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
+                           _InputIter2 __first2, _InputIter2 __last2,
+                           _OutputIter __result) {
+  return _STLP_PRIV __set_difference(__first1, __last1, __first2, __last2, __result,
+                                     _STLP_PRIV __less(_STLP_VALUE_TYPE(__first1, _InputIter1)));
+}
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+          class _Compare>
+_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
+                           _InputIter2 __first2, _InputIter2 __last2,
+                           _OutputIter __result, _Compare __comp) {
+  return _STLP_PRIV __set_difference(__first1, __last1, __first2, __last2, __result, __comp);
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+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) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+  while (__first1 != __last1 && __first2 != __last2) {
+    if (__comp(*__first1, *__first2)) {
+      _STLP_VERBOSE_ASSERT(!__comp(*__first2, *__first1), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      *__result = *__first1;
+      ++__first1;
+      ++__result;
+    }
+    else if (__comp(*__first2, *__first1)) {
+      *__result = *__first2;
+      ++__first2;
+      ++__result;
+    }
+    else {
+      ++__first1;
+      ++__first2;
+    }
+  }
+  return _STLP_STD::copy(__first2, __last2, _STLP_STD::copy(__first1, __last1, __result));
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter
+set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
+                         _InputIter2 __first2, _InputIter2 __last2,
+                         _OutputIter __result) {
+  return _STLP_PRIV __set_symmetric_difference(__first1, __last1, __first2, __last2, __result,
+                                               _STLP_PRIV __less(_STLP_VALUE_TYPE(__first1, _InputIter1)));
+}
+
+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) {
+  return _STLP_PRIV __set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp);
+}
+
+// min_element and max_element, with and without an explicitly supplied
+// comparison function.
+
+template <class _ForwardIter>
+_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  if (__first == __last) return __first;
+  _ForwardIter __result = __first;
+  while (++__first != __last)
+    if (*__result < *__first) {
+      _STLP_VERBOSE_ASSERT(!(*__first < *__result), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      __result = __first;
+    }
+  return __result;
+}
+
+template <class _ForwardIter, class _Compare>
+_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last,
+                         _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  if (__first == __last) return __first;
+  _ForwardIter __result = __first;
+  while (++__first != __last) {
+    if (__comp(*__result, *__first)) {
+      _STLP_VERBOSE_ASSERT(!__comp(*__first, *__result), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      __result = __first;
+    }
+  }
+  return __result;
+}
+
+template <class _ForwardIter>
+_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  if (__first == __last) return __first;
+  _ForwardIter __result = __first;
+  while (++__first != __last)
+    if (*__first < *__result) {
+      _STLP_VERBOSE_ASSERT(!(*__result < *__first), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      __result = __first;
+    }
+  return __result;
+}
+
+template <class _ForwardIter, class _Compare>
+_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last,
+                         _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  if (__first == __last) return __first;
+  _ForwardIter __result = __first;
+  while (++__first != __last) {
+    if (__comp(*__first, *__result)) {
+      _STLP_VERBOSE_ASSERT(!__comp(*__result, *__first), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      __result = __first;
+    }
+  }
+  return __result;
+}
+
+// next_permutation and prev_permutation, with and without an explicitly
+// supplied comparison function.
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _BidirectionalIter, class _Compare>
+bool __next_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
+                        _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  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)) {
+      _STLP_VERBOSE_ASSERT(!__comp(*__ii, *__i), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      _BidirectionalIter __j = __last;
+      while (!__comp(*__i, *--__j)) {}
+      iter_swap(__i, __j);
+      reverse(__ii, __last);
+      return true;
+    }
+    if (__i == __first) {
+      reverse(__first, __last);
+      return false;
+    }
+  }
+#if defined (_STLP_NEED_UNREACHABLE_RETURN)
+    return false;
+#endif
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _BidirectionalIter>
+bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  return _STLP_PRIV __next_permutation(__first, __last,
+                                       _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _BidirectionalIter)));
+}
+
+template <class _BidirectionalIter, class _Compare>
+bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
+                      _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  return _STLP_PRIV __next_permutation(__first, __last, __comp);
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+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)) {
+      _STLP_VERBOSE_ASSERT(!__comp(*__i, *__ii), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      _BidirectionalIter __j = __last;
+      while (!__comp(*--__j, *__i)) {}
+      iter_swap(__i, __j);
+      reverse(__ii, __last);
+      return true;
+    }
+    if (__i == __first) {
+      reverse(__first, __last);
+      return false;
+    }
+  }
+#if defined (_STLP_NEED_UNREACHABLE_RETURN)
+    return false;
+#endif
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _BidirectionalIter>
+bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  return _STLP_PRIV __prev_permutation(__first, __last,
+                                       _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _BidirectionalIter)));
+}
+
+template <class _BidirectionalIter, class _Compare>
+bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
+                      _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  return _STLP_PRIV __prev_permutation(__first, __last, __comp);
+}
+
+#if !defined (_STLP_NO_EXTENSIONS)
+
+// is_heap, a predicate testing whether or not a range is
+// a heap.  This function is an extension, not part of the C++
+// standard.
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+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])) {
+      _STLP_VERBOSE_ASSERT(!__comp(__first[__child], __first[__parent]), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      return false;
+    }
+    if ((__child & 1) == 0)
+      ++__parent;
+  }
+  return true;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _RandomAccessIter>
+bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  return _STLP_PRIV __is_heap(__first, _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _RandomAccessIter)), __last - __first);
+}
+
+template <class _RandomAccessIter, class _StrictWeakOrdering>
+bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last,
+             _StrictWeakOrdering __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  return _STLP_PRIV __is_heap(__first, __comp, __last - __first);
+}
+
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _StrictWeakOrdering>
+bool __is_sorted(_ForwardIter __first, _ForwardIter __last,
+                 _StrictWeakOrdering __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  if (__first == __last)
+    return true;
+
+  _ForwardIter __next = __first;
+  for (++__next; __next != __last; __first = __next, ++__next) {
+    if (__comp(*__next, *__first)) {
+      _STLP_VERBOSE_ASSERT(!__comp(*__first, *__next), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      return false;
+    }
+  }
+
+  return true;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif /* _STLP_NO_EXTENSIONS */
+
+_STLP_END_NAMESPACE
+
+#undef __stl_threshold
+
+#endif /* _STLP_ALGO_C */
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_algo.h b/stlport/stlport/stl/_algo.h
new file mode 100644
index 0000000..01e5f93
--- /dev/null
+++ b/stlport/stlport/stl/_algo.h
@@ -0,0 +1,745 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_ALGO_H
+#define _STLP_INTERNAL_ALGO_H
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+#  include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_INTERNAL_HEAP_H
+#  include <stl/_heap.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_H
+#  include <stl/_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+#  include <stl/_function_base.h>
+#endif
+
+#if defined (__SUNPRO_CC) && !defined (_STLP_INTERNAL_CSTDIO)
+// remove() conflict
+#  include <stl/_cstdio.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+// for_each.  Apply a function to every element of a range.
+template <class _InputIter, class _Function>
+_STLP_INLINE_LOOP _Function
+for_each(_InputIter __first, _InputIter __last, _Function __f) {
+  for ( ; __first != __last; ++__first)
+    __f(*__first);
+  return __f;
+}
+
+// count_if
+template <class _InputIter, class _Predicate>
+_STLP_INLINE_LOOP _STLP_DIFFERENCE_TYPE(_InputIter)
+count_if(_InputIter __first, _InputIter __last, _Predicate __pred) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  _STLP_DIFFERENCE_TYPE(_InputIter) __n = 0;
+  for ( ; __first != __last; ++__first) {
+    if (__pred(*__first))
+      ++__n;
+  }
+  return __n;
+}
+
+// adjacent_find.
+
+template <class _ForwardIter, class _BinaryPredicate>
+_STLP_INLINE_LOOP _ForwardIter
+adjacent_find(_ForwardIter __first, _ForwardIter __last,
+              _BinaryPredicate __binary_pred) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  if (__first == __last)
+    return __last;
+  _ForwardIter __next = __first;
+  while(++__next != __last) {
+    if (__binary_pred(*__first, *__next))
+      return __first;
+    __first = __next;
+  }
+  return __last;
+}
+
+template <class _ForwardIter>
+_STLP_INLINE_LOOP _ForwardIter
+adjacent_find(_ForwardIter __first, _ForwardIter __last) {
+  return adjacent_find(__first, __last,
+                       _STLP_PRIV __equal_to(_STLP_VALUE_TYPE(__first, _ForwardIter)));
+}
+
+#if !defined (_STLP_NO_ANACHRONISMS)
+template <class _InputIter, class _Tp, class _Size>
+_STLP_INLINE_LOOP void
+count(_InputIter __first, _InputIter __last, const _Tp& __val, _Size& __n) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+    for ( ; __first != __last; ++__first)
+      if (*__first == __val)
+        ++__n;
+}
+
+template <class _InputIter, class _Predicate, class _Size>
+_STLP_INLINE_LOOP void
+count_if(_InputIter __first, _InputIter __last, _Predicate __pred, _Size& __n) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  for ( ; __first != __last; ++__first)
+    if (__pred(*__first))
+      ++__n;
+}
+#endif
+
+template <class _ForwardIter1, class _ForwardIter2>
+_ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
+                     _ForwardIter2 __first2, _ForwardIter2 __last2);
+
+// 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);
+template <class _ForwardIter, class _Integer, class _Tp, class _BinaryPred>
+_ForwardIter search_n(_ForwardIter __first, _ForwardIter __last,
+                      _Integer __count, const _Tp& __val, _BinaryPred __binary_pred);
+
+template <class _InputIter, class _ForwardIter>
+inline _InputIter find_first_of(_InputIter __first1, _InputIter __last1,
+                                _ForwardIter __first2, _ForwardIter __last2) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+  return _STLP_PRIV __find_first_of(__first1, __last1, __first2, __last2);
+}
+
+template <class _InputIter, class _ForwardIter, class _BinaryPredicate>
+inline _InputIter
+find_first_of(_InputIter __first1, _InputIter __last1,
+              _ForwardIter __first2, _ForwardIter __last2, _BinaryPredicate __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+  return _STLP_PRIV __find_first_of(__first1, __last1, __first2, __last2, __comp);
+}
+
+template <class _ForwardIter1, class _ForwardIter2>
+_ForwardIter1
+find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
+         _ForwardIter2 __first2, _ForwardIter2 __last2);
+
+// swap_ranges
+template <class _ForwardIter1, class _ForwardIter2>
+_STLP_INLINE_LOOP _ForwardIter2
+swap_ranges(_ForwardIter1 __first1, _ForwardIter1 __last1, _ForwardIter2 __first2) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+  for ( ; __first1 != __last1; ++__first1, ++__first2)
+    iter_swap(__first1, __first2);
+  return __first2;
+}
+
+// transform
+template <class _InputIter, class _OutputIter, class _UnaryOperation>
+_STLP_INLINE_LOOP _OutputIter
+transform(_InputIter __first, _InputIter __last, _OutputIter __result, _UnaryOperation __opr) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  for ( ; __first != __last; ++__first, ++__result)
+    *__result = __opr(*__first);
+  return __result;
+}
+template <class _InputIter1, class _InputIter2, class _OutputIter, class _BinaryOperation>
+_STLP_INLINE_LOOP _OutputIter
+transform(_InputIter1 __first1, _InputIter1 __last1,
+          _InputIter2 __first2, _OutputIter __result,_BinaryOperation __binary_op) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+  for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result)
+    *__result = __binary_op(*__first1, *__first2);
+  return __result;
+}
+
+// replace_if, replace_copy, replace_copy_if
+
+template <class _ForwardIter, class _Predicate, class _Tp>
+_STLP_INLINE_LOOP void
+replace_if(_ForwardIter __first, _ForwardIter __last, _Predicate __pred, const _Tp& __new_value) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  for ( ; __first != __last; ++__first)
+    if (__pred(*__first))
+      *__first = __new_value;
+}
+
+template <class _InputIter, class _OutputIter, class _Tp>
+_STLP_INLINE_LOOP  _OutputIter
+replace_copy(_InputIter __first, _InputIter __last,_OutputIter __result,
+             const _Tp& __old_value, const _Tp& __new_value) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  for ( ; __first != __last; ++__first, ++__result)
+    *__result = *__first == __old_value ? __new_value : *__first;
+  return __result;
+}
+
+template <class _Iterator, class _OutputIter, class _Predicate, class _Tp>
+_STLP_INLINE_LOOP _OutputIter
+replace_copy_if(_Iterator __first, _Iterator __last,
+                _OutputIter __result,
+                _Predicate __pred, const _Tp& __new_value) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  for ( ; __first != __last; ++__first, ++__result)
+    *__result = __pred(*__first) ? __new_value : *__first;
+  return __result;
+}
+
+// generate and generate_n
+
+template <class _ForwardIter, class _Generator>
+_STLP_INLINE_LOOP void
+generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  for ( ; __first != __last; ++__first)
+    *__first = __gen();
+}
+
+template <class _OutputIter, class _Size, class _Generator>
+_STLP_INLINE_LOOP void
+generate_n(_OutputIter __first, _Size __n, _Generator __gen) {
+  for ( ; __n > 0; --__n, ++__first)
+    *__first = __gen();
+}
+
+// remove, remove_if, remove_copy, remove_copy_if
+
+template <class _InputIter, class _OutputIter, class _Tp>
+_STLP_INLINE_LOOP _OutputIter
+remove_copy(_InputIter __first, _InputIter __last,_OutputIter __result, const _Tp& __val) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  for ( ; __first != __last; ++__first) {
+    if (!(*__first == __val)) {
+      *__result = *__first;
+      ++__result;
+    }
+  }
+  return __result;
+}
+
+template <class _InputIter, class _OutputIter, class _Predicate>
+_STLP_INLINE_LOOP _OutputIter
+remove_copy_if(_InputIter __first, _InputIter __last, _OutputIter __result, _Predicate __pred) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  for ( ; __first != __last; ++__first) {
+    if (!__pred(*__first)) {
+      *__result = *__first;
+      ++__result;
+    }
+  }
+  return __result;
+}
+
+template <class _ForwardIter, class _Tp>
+_STLP_INLINE_LOOP _ForwardIter
+remove(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  __first = find(__first, __last, __val);
+  if (__first == __last)
+    return __first;
+  else {
+    _ForwardIter __next = __first;
+    return remove_copy(++__next, __last, __first, __val);
+  }
+}
+
+template <class _ForwardIter, class _Predicate>
+_STLP_INLINE_LOOP _ForwardIter
+remove_if(_ForwardIter __first, _ForwardIter __last, _Predicate __pred) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  __first = find_if(__first, __last, __pred);
+  if ( __first == __last )
+    return __first;
+  else {
+    _ForwardIter __next = __first;
+    return remove_copy_if(++__next, __last, __first, __pred);
+  }
+}
+
+// unique and unique_copy
+template <class _InputIter, class _OutputIter>
+_OutputIter unique_copy(_InputIter __first, _InputIter __last, _OutputIter __result);
+
+template <class _InputIter, class _OutputIter, class _BinaryPredicate>
+_OutputIter unique_copy(_InputIter __first, _InputIter __last,_OutputIter __result,
+                        _BinaryPredicate __binary_pred);
+
+template <class _ForwardIter>
+inline _ForwardIter unique(_ForwardIter __first, _ForwardIter __last) {
+  __first = adjacent_find(__first, __last);
+  return unique_copy(__first, __last, __first);
+}
+
+template <class _ForwardIter, class _BinaryPredicate>
+inline _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
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _BidirectionalIter>
+_STLP_INLINE_LOOP void
+__reverse(_BidirectionalIter __first, _BidirectionalIter __last, const bidirectional_iterator_tag &) {
+  for (; __first != __last && __first != --__last; ++__first)
+    _STLP_STD::iter_swap(__first,__last);
+}
+
+template <class _RandomAccessIter>
+_STLP_INLINE_LOOP void
+__reverse(_RandomAccessIter __first, _RandomAccessIter __last, const random_access_iterator_tag &) {
+  for (; __first < __last; ++__first)
+    _STLP_STD::iter_swap(__first, --__last);
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _BidirectionalIter>
+inline void
+reverse(_BidirectionalIter __first, _BidirectionalIter __last) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  _STLP_PRIV __reverse(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _BidirectionalIter));
+}
+
+template <class _BidirectionalIter, class _OutputIter>
+_STLP_INLINE_LOOP
+_OutputIter reverse_copy(_BidirectionalIter __first,
+                         _BidirectionalIter __last,
+                         _OutputIter __result) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  while (__first != __last) {
+    --__last;
+    *__result = *__last;
+    ++__result;
+  }
+  return __result;
+}
+
+template <class _ForwardIter>
+void rotate(_ForwardIter __first, _ForwardIter __middle, _ForwardIter __last);
+
+template <class _ForwardIter, class _OutputIter>
+inline _OutputIter rotate_copy(_ForwardIter __first, _ForwardIter __middle,
+                               _ForwardIter __last, _OutputIter __result) {
+  return _STLP_STD::copy(__first, __middle, copy(__middle, __last, __result));
+}
+
+// random_shuffle
+
+template <class _RandomAccessIter>
+void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last);
+
+template <class _RandomAccessIter, class _RandomNumberGenerator>
+void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last,
+                    _RandomNumberGenerator& __rand);
+
+#if !defined (_STLP_NO_EXTENSIONS)
+// 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_ite, const _Distance __n);
+
+template <class _ForwardIter, class _OutputIter, class _Distance,
+          class _RandomNumberGenerator>
+_OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last,
+                            _OutputIter __out_ite, const _Distance __n,
+                            _RandomNumberGenerator& __rand);
+
+template <class _InputIter, class _RandomAccessIter>
+_RandomAccessIter
+random_sample(_InputIter __first, _InputIter __last,
+              _RandomAccessIter __out_first, _RandomAccessIter __out_last);
+
+template <class _InputIter, class _RandomAccessIter,
+          class _RandomNumberGenerator>
+_RandomAccessIter
+random_sample(_InputIter __first, _InputIter __last,
+              _RandomAccessIter __out_first, _RandomAccessIter __out_last,
+              _RandomNumberGenerator& __rand);
+
+#endif /* _STLP_NO_EXTENSIONS */
+
+// partition, stable_partition, and their auxiliary functions
+
+template <class _ForwardIter, class _Predicate>
+_ForwardIter partition(_ForwardIter __first, _ForwardIter __last, _Predicate   __pred);
+
+template <class _ForwardIter, class _Predicate>
+_ForwardIter
+stable_partition(_ForwardIter __first, _ForwardIter __last, _Predicate __pred);
+
+// sort() and its auxiliary functions.
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Size>
+inline _Size __lg(_Size __n) {
+  _Size __k;
+  for (__k = 0; __n != 1; __n >>= 1) ++__k;
+  return __k;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _RandomAccessIter>
+void sort(_RandomAccessIter __first, _RandomAccessIter __last);
+template <class _RandomAccessIter, class _Compare>
+void sort(_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp);
+
+// stable_sort() and its auxiliary functions.
+template <class _RandomAccessIter>
+void stable_sort(_RandomAccessIter __first,
+                 _RandomAccessIter __last);
+
+template <class _RandomAccessIter, class _Compare>
+void stable_sort(_RandomAccessIter __first,
+                 _RandomAccessIter __last, _Compare __comp);
+
+// partial_sort, partial_sort_copy, and auxiliary functions.
+
+template <class _RandomAccessIter>
+void partial_sort(_RandomAccessIter __first, _RandomAccessIter __middle,
+                  _RandomAccessIter __last);
+
+template <class _RandomAccessIter, class _Compare>
+void partial_sort(_RandomAccessIter __first,_RandomAccessIter __middle,
+                  _RandomAccessIter __last, _Compare __comp);
+
+template <class _InputIter, class _RandomAccessIter>
+_RandomAccessIter
+partial_sort_copy(_InputIter __first, _InputIter __last,
+                  _RandomAccessIter __result_first, _RandomAccessIter __result_last);
+
+template <class _InputIter, class _RandomAccessIter, class _Compare>
+_RandomAccessIter
+partial_sort_copy(_InputIter __first, _InputIter __last,
+                  _RandomAccessIter __result_first,
+                  _RandomAccessIter __result_last, _Compare __comp);
+
+// nth_element() and its auxiliary functions.
+template <class _RandomAccessIter>
+void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
+                 _RandomAccessIter __last);
+
+template <class _RandomAccessIter, class _Compare>
+void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
+                 _RandomAccessIter __last, _Compare __comp);
+
+// auxiliary class for lower_bound, etc.
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _T1, class _T2>
+struct __less_2 {
+  bool operator() (const _T1& __x, const _T2& __y) const { return __x < __y ; }
+};
+
+template <class _T1, class _T2>
+__less_2<_T1,_T2> __less2(_T1*, _T2* ) { return __less_2<_T1, _T2>(); }
+
+#if defined (_STLP_FUNCTION_PARTIAL_ORDER)
+template <class _Tp>
+less<_Tp> __less2(_Tp*, _Tp* ) { return less<_Tp>(); }
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+// Binary search (lower_bound, upper_bound, equal_range, binary_search).
+template <class _ForwardIter, class _Tp>
+inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last,
+                                   const _Tp& __val) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  return _STLP_PRIV __lower_bound(__first, __last, __val,
+                                  _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),
+                                  _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),
+                                  _STLP_DISTANCE_TYPE(__first, _ForwardIter));
+}
+
+template <class _ForwardIter, class _Tp, class _Compare>
+inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last,
+                                const _Tp& __val, _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  return _STLP_PRIV __lower_bound(__first, __last, __val, __comp, __comp,
+                                  _STLP_DISTANCE_TYPE(__first, _ForwardIter));
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _Tp, class _Compare1, class _Compare2, class _Distance>
+_ForwardIter __upper_bound(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+                           _Compare1 __comp1, _Compare2 __comp2, _Distance*);
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _ForwardIter, class _Tp>
+inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last,
+                                const _Tp& __val) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  return _STLP_PRIV __upper_bound(__first, __last, __val,
+                                  _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),
+                                  _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),
+                                  _STLP_DISTANCE_TYPE(__first, _ForwardIter));
+}
+
+template <class _ForwardIter, class _Tp, class _Compare>
+inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last,
+                                const _Tp& __val, _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  return _STLP_PRIV __upper_bound(__first, __last, __val, __comp, __comp,
+                                  _STLP_DISTANCE_TYPE(__first, _ForwardIter));
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _Tp, class _Compare1, class _Compare2, class _Distance>
+pair<_ForwardIter, _ForwardIter>
+__equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+              _Compare1 __comp1, _Compare2 __comp2, _Distance*);
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _ForwardIter, class _Tp>
+inline pair<_ForwardIter, _ForwardIter>
+equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  return _STLP_PRIV __equal_range(__first, __last, __val,
+                                  _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),
+                                  _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),
+                                  _STLP_DISTANCE_TYPE(__first, _ForwardIter));
+}
+
+template <class _ForwardIter, class _Tp, class _Compare>
+inline pair<_ForwardIter, _ForwardIter>
+equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+            _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  return _STLP_PRIV __equal_range(__first, __last, __val, __comp, __comp,
+                                  _STLP_DISTANCE_TYPE(__first, _ForwardIter));
+}
+
+template <class _ForwardIter, class _Tp>
+inline bool binary_search(_ForwardIter __first, _ForwardIter __last,
+                   const _Tp& __val) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  _ForwardIter __i = _STLP_PRIV __lower_bound(__first, __last, __val,
+                                              _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),
+                                              _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),
+                                              _STLP_DISTANCE_TYPE(__first, _ForwardIter));
+  return __i != __last && !(__val < *__i);
+}
+
+template <class _ForwardIter, class _Tp, class _Compare>
+inline bool binary_search(_ForwardIter __first, _ForwardIter __last,
+                          const _Tp& __val,
+                          _Compare __comp) {
+  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+  _ForwardIter __i = _STLP_PRIV __lower_bound(__first, __last, __val, __comp, __comp,
+                                              _STLP_DISTANCE_TYPE(__first, _ForwardIter));
+  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);
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+          class _Compare>
+_OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,
+                  _InputIter2 __first2, _InputIter2 __last2,
+                  _OutputIter __result, _Compare __comp);
+
+
+// inplace_merge and its auxiliary functions.
+
+
+template <class _BidirectionalIter>
+void inplace_merge(_BidirectionalIter __first,
+                   _BidirectionalIter __middle,
+                   _BidirectionalIter __last) ;
+
+template <class _BidirectionalIter, class _Compare>
+void inplace_merge(_BidirectionalIter __first,
+                   _BidirectionalIter __middle,
+                   _BidirectionalIter __last, _Compare __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);
+
+template <class _InputIter1, class _InputIter2, class _Compare>
+bool includes(_InputIter1 __first1, _InputIter1 __last1,
+              _InputIter2 __first2, _InputIter2 __last2, _Compare __comp);
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
+                      _InputIter2 __first2, _InputIter2 __last2,
+                      _OutputIter __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);
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
+                             _InputIter2 __first2, _InputIter2 __last2,
+                             _OutputIter __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);
+
+
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
+                           _InputIter2 __first2, _InputIter2 __last2,
+                           _OutputIter __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);
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter
+set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
+                         _InputIter2 __first2, _InputIter2 __last2,
+                         _OutputIter __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);
+
+
+// min_element and max_element, with and without an explicitly supplied
+// comparison function.
+
+template <class _ForwardIter>
+_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last);
+template <class _ForwardIter, class _Compare>
+_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last,
+                            _Compare __comp);
+
+template <class _ForwardIter>
+_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last);
+
+template <class _ForwardIter, class _Compare>
+_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last,
+                            _Compare __comp);
+
+// next_permutation and prev_permutation, with and without an explicitly
+// supplied comparison function.
+
+template <class _BidirectionalIter>
+bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last);
+
+template <class _BidirectionalIter, class _Compare>
+bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
+                      _Compare __comp);
+
+
+template <class _BidirectionalIter>
+bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last);
+
+
+template <class _BidirectionalIter, class _Compare>
+bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
+                      _Compare __comp);
+
+#if !defined (_STLP_NO_EXTENSIONS)
+// 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>
+bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last);
+
+template <class _RandomAccessIter, class _StrictWeakOrdering>
+bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last,
+             _StrictWeakOrdering __comp);
+
+// is_sorted, a predicated testing whether a range is sorted in
+// nondescending order.  This is an extension, not part of the C++
+// standard.
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _StrictWeakOrdering>
+bool __is_sorted(_ForwardIter __first, _ForwardIter __last,
+                 _StrictWeakOrdering __comp);
+
+_STLP_MOVE_TO_STD_NAMESPACE
+template <class _ForwardIter>
+inline bool is_sorted(_ForwardIter __first, _ForwardIter __last) {
+  return _STLP_PRIV __is_sorted(__first, __last,
+                                _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _ForwardIter)));
+}
+
+template <class _ForwardIter, class _StrictWeakOrdering>
+inline bool is_sorted(_ForwardIter __first, _ForwardIter __last,
+                      _StrictWeakOrdering __comp) {
+  return _STLP_PRIV __is_sorted(__first, __last, __comp);
+}
+#endif
+
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+#  include <stl/_algo.c>
+#endif
+
+#endif /* _STLP_INTERNAL_ALGO_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/stlport/stlport/stl/_auto_ptr.h b/stlport/stlport/stl/_auto_ptr.h
new file mode 100644
index 0000000..c750534
--- /dev/null
+++ b/stlport/stlport/stl/_auto_ptr.h
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_AUTO_PTR_H
+#define _STLP_AUTO_PTR_H
+
+_STLP_BEGIN_NAMESPACE
+// implementation primitive
+class __ptr_base {
+public:
+  void* _M_p;
+  void  __set(const volatile void* p) { _M_p = __CONST_CAST(void*,p); }
+  void  __set(void* p) { _M_p = p; }
+};
+
+template <class _Tp>
+class auto_ptr_ref {
+public:
+  __ptr_base& _M_r;
+  _Tp* const _M_p;
+
+  auto_ptr_ref(__ptr_base& __r, _Tp* __p) : _M_r(__r), _M_p(__p) {  }
+
+  _Tp* release() const { _M_r.__set(__STATIC_CAST(void*, 0)); return _M_p; }
+
+private:
+  //explicitely defined as private to avoid warnings:
+  typedef auto_ptr_ref<_Tp> _Self;
+  _Self& operator = (_Self const&);
+};
+
+template<class _Tp>
+class auto_ptr :  public __ptr_base {
+public:
+  typedef _Tp element_type;
+  typedef auto_ptr<_Tp> _Self;
+
+  _Tp* release() _STLP_NOTHROW {
+    _Tp* __px = this->get();
+    this->_M_p = 0;
+    return __px;
+  }
+
+  void reset(_Tp* __px = 0) _STLP_NOTHROW {
+    _Tp* __pt = this->get();
+    if (__px != __pt)
+      delete __pt;
+    this->__set(__px);
+  }
+
+  _Tp* get() const _STLP_NOTHROW
+#if !defined (__GNUC__) || (__GNUC__ > 2)
+  { return __STATIC_CAST(_Tp*, _M_p); }
+#else
+  { return __REINTERPRET_CAST(_Tp*, _M_p); }
+#endif
+
+#if !defined (_STLP_NO_ARROW_OPERATOR)
+  _Tp* operator->() const _STLP_NOTHROW {
+    _STLP_VERBOSE_ASSERT(get() != 0, _StlMsg_AUTO_PTR_NULL)
+    return get();
+  }
+#endif
+  _Tp& operator*() const _STLP_NOTHROW {
+    _STLP_VERBOSE_ASSERT(get() != 0, _StlMsg_AUTO_PTR_NULL)
+    return *get();
+  }
+
+  explicit auto_ptr(_Tp* __px = 0) _STLP_NOTHROW { this->__set(__px); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+#  if !defined (_STLP_NO_TEMPLATE_CONVERSIONS)
+  template<class _Tp1> auto_ptr(auto_ptr<_Tp1>& __r) _STLP_NOTHROW {
+    _Tp* __conversionCheck = __r.release();
+    this->__set(__conversionCheck);
+  }
+#  endif
+  template<class _Tp1> auto_ptr<_Tp>& operator=(auto_ptr<_Tp1>& __r) _STLP_NOTHROW {
+    _Tp* __conversionCheck = __r.release();
+    reset(__conversionCheck);
+    return *this;
+  }
+#endif
+
+  auto_ptr(_Self& __r) _STLP_NOTHROW { this->__set(__r.release()); }
+
+  _Self& operator=(_Self& __r) _STLP_NOTHROW {
+    reset(__r.release());
+    return *this;
+  }
+
+  ~auto_ptr() _STLP_NOTHROW { /* boris : reset(0) might be better */ delete this->get(); }
+
+  auto_ptr(auto_ptr_ref<_Tp> __r) _STLP_NOTHROW
+  { this->__set(__r.release()); }
+
+  _Self& operator=(auto_ptr_ref<_Tp> __r) _STLP_NOTHROW {
+    reset(__r.release());
+    return *this;
+  }
+
+#if defined(_STLP_MEMBER_TEMPLATES) && !defined(_STLP_NO_TEMPLATE_CONVERSIONS)
+  template<class _Tp1> operator auto_ptr_ref<_Tp1>() _STLP_NOTHROW
+  { return auto_ptr_ref<_Tp1>(*this, this->get()); }
+  template<class _Tp1> operator auto_ptr<_Tp1>() _STLP_NOTHROW
+  { return auto_ptr<_Tp1>(release()); }
+#else
+  operator auto_ptr_ref<_Tp>() _STLP_NOTHROW
+  { return auto_ptr_ref<_Tp>(*this, this->get()); }
+#endif
+};
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_AUTO_PTR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_bitset.c b/stlport/stlport/stl/_bitset.c
new file mode 100644
index 0000000..82b9312
--- /dev/null
+++ b/stlport/stlport/stl/_bitset.c
@@ -0,0 +1,235 @@
+/*
+ * Copyright (c) 1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_BITSET_C
+#define _STLP_BITSET_C
+
+#ifndef _STLP_BITSET_H
+#  include <stl/_bitset.h>
+#endif
+
+#define __BITS_PER_WORD (CHAR_BIT * sizeof(unsigned long))
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+//
+// Definitions of non-inline functions from _Base_bitset.
+//
+template<size_t _Nw>
+void _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift) {
+  if (__shift != 0) {
+    const size_t __wshift = __shift / __BITS_PER_WORD;
+    const size_t __offset = __shift % __BITS_PER_WORD;
+
+    if (__offset == 0)
+      for (size_t __n = _Nw - 1; __n >= __wshift; --__n)
+        _M_w[__n] = _M_w[__n - __wshift];
+
+    else {
+      const size_t __sub_offset = __BITS_PER_WORD - __offset;
+      for (size_t __n = _Nw - 1; __n > __wshift; --__n)
+        _M_w[__n] = (_M_w[__n - __wshift] << __offset) |
+                    (_M_w[__n - __wshift - 1] >> __sub_offset);
+      _M_w[__wshift] = _M_w[0] << __offset;
+    }
+
+    fill(_M_w + 0, _M_w + __wshift, __STATIC_CAST(_WordT,0));
+  }
+}
+
+template<size_t _Nw>
+void _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) {
+  if (__shift != 0) {
+    const size_t __wshift = __shift / __BITS_PER_WORD;
+    const size_t __offset = __shift % __BITS_PER_WORD;
+    const size_t __limit = _Nw - __wshift - 1;
+
+    if (__offset == 0)
+      for (size_t __n = 0; __n <= __limit; ++__n)
+        _M_w[__n] = _M_w[__n + __wshift];
+
+    else {
+      const size_t __sub_offset = __BITS_PER_WORD - __offset;
+      for (size_t __n = 0; __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;
+    }
+
+    fill(_M_w + __limit + 1, _M_w + _Nw, __STATIC_CAST(_WordT,0));
+  }
+}
+
+template<size_t _Nw>
+unsigned long _Base_bitset<_Nw>::_M_do_to_ulong() const {
+  for (size_t __i = 1; __i < _Nw; ++__i)
+    if (_M_w[__i])
+      __stl_throw_overflow_error("bitset");
+  return _M_w[0];
+} // End _M_do_to_ulong
+
+template<size_t _Nw>
+size_t _Base_bitset<_Nw>::_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_WORD + __j*CHAR_BIT +
+            _Bs_G::_S_first_one(__this_byte);
+
+        __thisword >>= CHAR_BIT;
+      }
+    }
+  }
+  // not found, so return an indication of failure.
+  return __not_found;
+}
+
+template<size_t _Nw>
+size_t
+_Base_bitset<_Nw>::_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_WORD )
+    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_WORD + __j*CHAR_BIT +
+          _Bs_G::_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_WORD + __j*CHAR_BIT +
+            _Bs_G::_S_first_one(__this_byte);
+
+        __thisword >>= CHAR_BIT;
+      }
+    }
+  }
+
+  // not found, so return an indication of failure.
+  return __not_found;
+} // end _M_do_find_next
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#if !defined (_STLP_NON_TYPE_TMPL_PARAM_BUG)
+
+#  if !defined (_STLP_USE_NO_IOSTREAMS)
+
+_STLP_END_NAMESPACE
+
+#ifndef _STLP_STRING_IO_H
+#  include <stl/_string_io.h> //includes _istream.h and _ostream.h
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _CharT, class _Traits, size_t _Nb>
+basic_istream<_CharT, _Traits>& _STLP_CALL
+operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x) {
+  basic_string<_CharT, _Traits> __tmp;
+  __tmp.reserve(_Nb);
+
+  // Skip whitespace
+  typename basic_istream<_CharT, _Traits>::sentry __sentry(__is);
+  if (__sentry) {
+    basic_streambuf<_CharT, _Traits>* __buf = __is.rdbuf();
+    for (size_t __i = 0; __i < _Nb; ++__i) {
+      static typename _Traits::int_type __eof = _Traits::eof();
+
+      typename _Traits::int_type __c1 = __buf->sbumpc();
+      if (_Traits::eq_int_type(__c1, __eof)) {
+        __is.setstate(ios_base::eofbit);
+        break;
+      }
+      else {
+        typename _Traits::char_type __c2 = _Traits::to_char_type(__c1);
+        char __c = __is.narrow(__c2, '*');
+
+        if (__c == '0' || __c == '1')
+          __tmp.push_back(__c);
+        else if (_Traits::eq_int_type(__buf->sputbackc(__c2), __eof)) {
+          __is.setstate(ios_base::failbit);
+          break;
+        }
+      }
+    }
+
+    if (__tmp.empty())
+      __is.setstate(ios_base::failbit);
+    else
+      __x._M_copy_from_string(__tmp, __STATIC_CAST(size_t,0), _Nb);
+  }
+
+  return __is;
+}
+
+template <class _CharT, class _Traits, size_t _Nb>
+basic_ostream<_CharT, _Traits>& _STLP_CALL
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+           const bitset<_Nb>& __x) {
+  basic_string<_CharT, _Traits> __tmp;
+  __x._M_copy_to_string(__tmp);
+  return __os << __tmp;
+}
+
+#  endif /* !_STLP_USE_NO_IOSTREAMS */
+
+#endif /* _STLP_NON_TYPE_TMPL_PARAM_BUG */
+
+_STLP_END_NAMESPACE
+
+#undef __BITS_PER_WORD
+#undef bitset
+
+#endif /*  _STLP_BITSET_C */
diff --git a/stlport/stlport/stl/_bitset.h b/stlport/stlport/stl/_bitset.h
new file mode 100644
index 0000000..f894346
--- /dev/null
+++ b/stlport/stlport/stl/_bitset.h
@@ -0,0 +1,880 @@
+/*
+ * Copyright (c) 1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_BITSET_H
+#define _STLP_BITSET_H
+
+// A bitset of size N has N % (sizeof(unsigned long) * 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.
+
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+#  include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+#  include <stl/_alloc.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_H
+#  include <stl/_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_UNINITIALIZED_H
+#  include <stl/_uninitialized.h>
+#endif
+
+#ifndef _STLP_RANGE_ERRORS_H
+#  include <stl/_range_errors.h>
+#endif
+
+#ifndef _STLP_INTERNAL_STRING_H
+#  include <stl/_string.h>
+#endif
+
+#define __BITS_PER_WORD (CHAR_BIT*sizeof(unsigned long))
+#define __BITSET_WORDS(__n) ((__n + __BITS_PER_WORD - 1)/__BITS_PER_WORD)
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// structure to aid in counting bits
+class _STLP_CLASS_DECLSPEC _Bs_G
+{
+  public:
+    //returns the number of bit set within the buffer between __beg and __end.
+    static size_t _S_count(const unsigned char *__beg, const unsigned char *__end)
+#if defined (_STLP_USE_NO_IOSTREAMS)
+    {
+      size_t __result = 0;
+      for (; __beg != __end; ++__beg) {
+        for (size_t i = 0; i < (sizeof(unsigned char) * 8); ++i) {
+          if ((*__beg & (1 << i)) != 0) { ++__result; }
+        }
+      }
+      return __result;
+    }
+#else
+      ;
+#endif
+    // Mapping from 8 bit unsigned integers to the index of the first one bit set:
+    static unsigned char _S_first_one(unsigned char __x)
+#if defined (_STLP_USE_NO_IOSTREAMS)
+    {
+      for (unsigned char i = 0; i < (sizeof(unsigned char) * 8); ++i) {
+        if ((__x & (1 << i)) != 0) { return i; }
+      }
+      return 0;
+    }
+#else
+      ;
+#endif
+};
+
+//
+// Base class: general case.
+//
+
+template<size_t _Nw>
+struct _Base_bitset {
+  typedef unsigned long _WordT;
+
+  _WordT _M_w[_Nw];                // 0 is the least significant word.
+
+  _Base_bitset() { _M_do_reset(); }
+
+  _Base_bitset(unsigned long __val) {
+    _M_do_reset();
+    _M_w[0] = __val;
+  }
+
+  static size_t _STLP_CALL _S_whichword( size_t __pos ) {
+    return __pos / __BITS_PER_WORD;
+  }
+  static size_t _STLP_CALL _S_whichbyte( size_t __pos ) {
+    return (__pos % __BITS_PER_WORD) / CHAR_BIT;
+  }
+  static size_t _STLP_CALL _S_whichbit( size_t __pos ) {
+    return __pos % __BITS_PER_WORD;
+  }
+  static _WordT _STLP_CALL _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>& __x) {
+    for ( size_t __i = 0; __i < _Nw; __i++ ) {
+      _M_w[__i] &= __x._M_w[__i];
+    }
+  }
+
+  void _M_do_or(const _Base_bitset<_Nw>& __x) {
+    for ( size_t __i = 0; __i < _Nw; __i++ ) {
+      _M_w[__i] |= __x._M_w[__i];
+    }
+  }
+
+  void _M_do_xor(const _Base_bitset<_Nw>& __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() { memset(_M_w, 0, _Nw * sizeof(_WordT)); }
+
+  bool _M_is_equal(const _Base_bitset<_Nw>& __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 < _Nw ; __i++ ) {
+      if ( _M_w[__i] != __STATIC_CAST(_WordT,0) )
+        return true;
+    }
+    return false;
+  }
+
+  size_t _M_do_count() const {
+    const unsigned char* __byte_ptr = (const unsigned char*)_M_w;
+    const unsigned char* __end_ptr = (const unsigned char*)(_M_w+_Nw);
+
+    return _Bs_G::_S_count(__byte_ptr, __end_ptr);
+  }
+
+  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;
+};
+
+//
+// Base class: specialization for a single word.
+//
+_STLP_TEMPLATE_NULL
+struct _Base_bitset<1UL> {
+  typedef unsigned long _WordT;
+  typedef _Base_bitset<1UL> _Self;
+
+  _WordT _M_w;
+
+  _Base_bitset( void ) : _M_w(0) {}
+  _Base_bitset(unsigned long __val) : _M_w(__val) {}
+
+  static size_t _STLP_CALL _S_whichword( size_t __pos ) {
+    return __pos / __BITS_PER_WORD ;
+  }
+  static size_t _STLP_CALL _S_whichbyte( size_t __pos ) {
+    return (__pos % __BITS_PER_WORD) / CHAR_BIT;
+  }
+  static size_t _STLP_CALL _S_whichbit( size_t __pos ) {
+    return __pos % __BITS_PER_WORD;
+  }
+  static _WordT _STLP_CALL _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 _Self& __x) { _M_w &= __x._M_w; }
+  void _M_do_or(const _Self& __x)  { _M_w |= __x._M_w; }
+  void _M_do_xor(const _Self& __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 _Self& __x) const {
+    return _M_w == __x._M_w;
+  }
+  bool _M_is_any() const {
+    return _M_w != 0;
+  }
+
+  size_t _M_do_count() const {
+    const unsigned char* __byte_ptr = (const unsigned char*)&_M_w;
+    const unsigned char* __end_ptr = ((const unsigned char*)&_M_w)+sizeof(_M_w);
+    return _Bs_G::_S_count(__byte_ptr, __end_ptr);
+  }
+
+  unsigned long _M_do_to_ulong() const { return _M_w; }
+
+  inline size_t _M_do_find_first(size_t __not_found) const;
+
+  // find the next "on" bit that follows "prev"
+  inline size_t _M_do_find_next(size_t __prev, size_t __not_found) const;
+};
+
+
+// ------------------------------------------------------------
+//
+// Definitions of should-be-non-inline functions from the single-word version of
+//  _Base_bitset.
+//
+inline size_t
+_Base_bitset<1UL>::_M_do_find_first(size_t __not_found) const {
+  //  typedef unsigned long _WordT;
+  _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 + _Bs_G::_S_first_one(__this_byte);
+
+      __thisword >>= CHAR_BIT;
+    }
+  }
+  // not found, so return a value that indicates failure.
+  return __not_found;
+}
+
+inline size_t
+_Base_bitset<1UL>::_M_do_find_next(size_t __prev,
+                                   size_t __not_found ) const {
+  // make bound inclusive
+  ++__prev;
+
+  // check out of bounds
+  if ( __prev >= __BITS_PER_WORD )
+    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 + _Bs_G::_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
+
+
+// ------------------------------------------------------------
+// Helper class to zero out the unused high-order bits in the highest word.
+
+template <size_t _Extrabits> struct _Sanitize {
+  static void _STLP_CALL _M_do_sanitize(unsigned long& __val)
+  { __val &= ~((~__STATIC_CAST(unsigned long,0)) << _Extrabits); }
+};
+
+_STLP_TEMPLATE_NULL struct _Sanitize<0UL> {
+  static void _STLP_CALL _M_do_sanitize(unsigned long) {}
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+// ------------------------------------------------------------
+// Class bitset.
+//   _Nb may be any nonzero number of type size_t.
+template<size_t _Nb>
+class bitset : public _STLP_PRIV _Base_bitset<__BITSET_WORDS(_Nb) > {
+public:
+  enum { _Words = __BITSET_WORDS(_Nb) } ;
+
+private:
+  typedef _STLP_PRIV _Base_bitset< _Words > _Base;
+
+  void _M_do_sanitize() {
+    _STLP_PRIV _Sanitize<_Nb%__BITS_PER_WORD >::_M_do_sanitize(this->_M_hiword());
+  }
+public:
+  typedef unsigned long _WordT;
+  struct reference;
+  friend struct reference;
+
+  // bit reference:
+  struct reference {
+  typedef _STLP_PRIV _Base_bitset<_Words > _Bitset_base;
+  typedef bitset<_Nb> _Bitset;
+    //    friend _Bitset;
+    _WordT *_M_wp;
+    size_t _M_bpos;
+
+    // should be left undefined
+    reference() {}
+
+    reference( _Bitset& __b, size_t __pos ) {
+      _M_wp = &__b._M_getword(__pos);
+      _M_bpos = _Bitset_base::_S_whichbit(__pos);
+    }
+
+  public:
+    ~reference() {}
+
+    // for b[i] = __x;
+    reference& operator=(bool __x) {
+      if ( __x )
+        *_M_wp |= _Bitset_base::_S_maskbit(_M_bpos);
+      else
+        *_M_wp &= ~_Bitset_base::_S_maskbit(_M_bpos);
+
+      return *this;
+    }
+
+    // for b[i] = b[__j];
+    reference& operator=(const reference& __j) {
+      if ( (*(__j._M_wp) & _Bitset_base::_S_maskbit(__j._M_bpos)) )
+        *_M_wp |= _Bitset_base::_S_maskbit(_M_bpos);
+      else
+        *_M_wp &= ~_Bitset_base::_S_maskbit(_M_bpos);
+
+      return *this;
+    }
+
+    // flips the bit
+    bool operator~() const { return (*(_M_wp) & _Bitset_base::_S_maskbit(_M_bpos)) == 0; }
+
+    // for __x = b[i];
+    operator bool() const { return (*(_M_wp) & _Bitset_base::_S_maskbit(_M_bpos)) != 0; }
+
+    // for b[i].flip();
+    reference& flip() {
+      *_M_wp ^= _Bitset_base::_S_maskbit(_M_bpos);
+      return *this;
+    }
+  };
+
+  // 23.3.5.1 constructors:
+  bitset() {}
+
+  bitset(unsigned long __val) : _STLP_PRIV _Base_bitset<_Words>(__val) { _M_do_sanitize(); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template<class _CharT, class _Traits, class _Alloc>
+  explicit bitset(const basic_string<_CharT,_Traits,_Alloc>& __s,
+                  size_t __pos = 0)
+    : _STLP_PRIV _Base_bitset<_Words >() {
+    if (__pos > __s.size())
+      __stl_throw_out_of_range("bitset");
+    _M_copy_from_string(__s, __pos,
+                        basic_string<_CharT, _Traits, _Alloc>::npos);
+  }
+  template<class _CharT, class _Traits, class _Alloc>
+  bitset(const basic_string<_CharT, _Traits, _Alloc>& __s,
+          size_t __pos,
+          size_t __n)
+  : _STLP_PRIV _Base_bitset<_Words >() {
+    if (__pos > __s.size())
+      __stl_throw_out_of_range("bitset");
+    _M_copy_from_string(__s, __pos, __n);
+  }
+#else /* _STLP_MEMBER_TEMPLATES */
+  explicit bitset(const string& __s,
+                  size_t __pos = 0,
+                  size_t __n = (size_t)-1)
+    : _STLP_PRIV _Base_bitset<_Words >() {
+    if (__pos > __s.size())
+      __stl_throw_out_of_range("bitset");
+    _M_copy_from_string(__s, __pos, __n);
+  }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+  // 23.3.5.2 bitset operations:
+  bitset<_Nb>& operator&=(const bitset<_Nb>& __rhs) {
+    this->_M_do_and(__rhs);
+    return *this;
+  }
+
+  bitset<_Nb>& operator|=(const bitset<_Nb>& __rhs) {
+    this->_M_do_or(__rhs);
+    return *this;
+  }
+
+  bitset<_Nb>& operator^=(const bitset<_Nb>& __rhs) {
+    this->_M_do_xor(__rhs);
+    return *this;
+  }
+
+  bitset<_Nb>& operator<<=(size_t __pos) {
+    this->_M_do_left_shift(__pos);
+    this->_M_do_sanitize();
+    return *this;
+  }
+
+  bitset<_Nb>& operator>>=(size_t __pos) {
+    this->_M_do_right_shift(__pos);
+    this->_M_do_sanitize();
+    return *this;
+  }
+
+  //
+  // Extension:
+  // Versions of single-bit set, reset, flip, test with no range checking.
+  //
+
+  bitset<_Nb>& _Unchecked_set(size_t __pos) {
+    this->_M_getword(__pos) |= _STLP_PRIV _Base_bitset<_Words > ::_S_maskbit(__pos);
+    return *this;
+  }
+
+  bitset<_Nb>& _Unchecked_set(size_t __pos, int __val) {
+    if (__val)
+      this->_M_getword(__pos) |= this->_S_maskbit(__pos);
+    else
+      this->_M_getword(__pos) &= ~ this->_S_maskbit(__pos);
+
+    return *this;
+  }
+
+  bitset<_Nb>& _Unchecked_reset(size_t __pos) {
+    this->_M_getword(__pos) &= ~ this->_S_maskbit(__pos);
+    return *this;
+  }
+
+  bitset<_Nb>& _Unchecked_flip(size_t __pos) {
+    this->_M_getword(__pos) ^= this->_S_maskbit(__pos);
+    return *this;
+  }
+
+  bool _Unchecked_test(size_t __pos) const {
+    return (this->_M_getword(__pos) & this->_S_maskbit(__pos)) != __STATIC_CAST(_WordT,0);
+  }
+
+  // Set, reset, and flip.
+
+  bitset<_Nb>& set() {
+    this->_M_do_set();
+    this->_M_do_sanitize();
+    return *this;
+  }
+
+  bitset<_Nb>& set(size_t __pos) {
+    if (__pos >= _Nb)
+      __stl_throw_out_of_range("bitset");
+    return _Unchecked_set(__pos);
+  }
+
+  bitset<_Nb>& set(size_t __pos, int __val) {
+    if (__pos >= _Nb)
+      __stl_throw_out_of_range("bitset");
+    return _Unchecked_set(__pos, __val);
+  }
+
+  bitset<_Nb>& reset() {
+    this->_M_do_reset();
+    return *this;
+  }
+
+  bitset<_Nb>& reset(size_t __pos) {
+    if (__pos >= _Nb)
+      __stl_throw_out_of_range("bitset");
+
+    return _Unchecked_reset(__pos);
+  }
+
+  bitset<_Nb>& flip() {
+    this->_M_do_flip();
+    this->_M_do_sanitize();
+    return *this;
+  }
+
+  bitset<_Nb>& flip(size_t __pos) {
+    if (__pos >= _Nb)
+      __stl_throw_out_of_range("bitset");
+
+    return _Unchecked_flip(__pos);
+  }
+
+  bitset<_Nb> operator~() const {
+    return bitset<_Nb>(*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 this->_M_do_to_ulong(); }
+
+#if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_NO_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;
+  }
+#else
+  string to_string() const {
+    string __result;
+    _M_copy_to_string(__result);
+    return __result;
+  }
+#endif /* _STLP_EXPLICIT_FUNCTION_TMPL_ARGS */
+
+  size_t count() const { return this->_M_do_count(); }
+
+  size_t size() const { return _Nb; }
+
+  bool operator==(const bitset<_Nb>& __rhs) const {
+    return this->_M_is_equal(__rhs);
+  }
+  bool operator!=(const bitset<_Nb>& __rhs) const {
+    return !this->_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 this->_M_is_any(); }
+  bool none() const { return !this->_M_is_any(); }
+
+  bitset<_Nb> operator<<(size_t __pos) const {
+    bitset<_Nb> __result(*this);
+    __result <<= __pos ;  return __result;
+  }
+  bitset<_Nb> operator>>(size_t __pos) const {
+    bitset<_Nb> __result(*this);
+    __result >>= __pos ;  return __result;
+  }
+
+#if !defined (_STLP_NO_EXTENSIONS)
+  //
+  // 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 this->_M_do_find_first(_Nb); }
+
+  // find the index of the next "on" bit after prev
+  size_t _Find_next( size_t __prev ) const
+    { return this->_M_do_find_next(__prev, _Nb); }
+#endif
+
+//
+// Definitions of should-be non-inline member functions.
+//
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template<class _CharT, class _Traits, class _Alloc>
+  void _M_copy_from_string(const basic_string<_CharT,_Traits,_Alloc>& __s,
+                           size_t __pos, size_t __n) {
+#else
+  void _M_copy_from_string(const string& __s,
+                           size_t __pos, size_t __n) {
+    typedef typename string::traits_type _Traits;
+#endif
+    reset();
+    size_t __tmp = _Nb;
+    const size_t __Nbits = (min) (__tmp, (min) (__n, __s.size() - __pos));
+    for ( size_t __i= 0; __i < __Nbits; ++__i) {
+      typename _Traits::int_type __k = _Traits::to_int_type(__s[__pos + __Nbits - __i - 1]);
+      // boris : widen() ?
+      if (__k == '1')
+        set(__i);
+      else if (__k != '0')
+        __stl_throw_invalid_argument("bitset");
+    }
+  }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _CharT, class _Traits, class _Alloc>
+  void _M_copy_to_string(basic_string<_CharT, _Traits, _Alloc>& __s) const
+#else
+  void _M_copy_to_string(string& __s) const
+#endif
+  {
+    __s.assign(_Nb, '0');
+
+    for (size_t __i = 0; __i < _Nb; ++__i) {
+      if (_Unchecked_test(__i))
+        __s[_Nb - 1 - __i] = '1';
+    }
+  }
+
+#if !defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_NO_WCHAR_T)
+  void _M_copy_to_string(wstring& __s) const {
+    __s.assign(_Nb, '0');
+
+    for (size_t __i = 0; __i < _Nb; ++__i) {
+      if (_Unchecked_test(__i))
+        __s[_Nb - 1 - __i] = '1';
+    }
+  }
+#endif
+
+#if defined (_STLP_NON_TYPE_TMPL_PARAM_BUG)
+  bitset<_Nb> operator&(const bitset<_Nb>& __y) const {
+    bitset<_Nb> __result(*this);
+    __result &= __y;
+    return __result;
+  }
+  bitset<_Nb> operator|(const bitset<_Nb>& __y) const {
+    bitset<_Nb> __result(*this);
+    __result |= __y;
+    return __result;
+  }
+  bitset<_Nb> operator^(const bitset<_Nb>& __y) const {
+    bitset<_Nb> __result(*this);
+    __result ^= __y;
+    return __result;
+  }
+#endif
+};
+
+// ------------------------------------------------------------
+//
+// 23.3.5.3 bitset operations:
+//
+#if ! defined (_STLP_NON_TYPE_TMPL_PARAM_BUG)
+template <size_t _Nb>
+inline bitset<_Nb>  _STLP_CALL
+operator&(const bitset<_Nb>& __x,
+          const bitset<_Nb>& __y) {
+  bitset<_Nb> __result(__x);
+  __result &= __y;
+  return __result;
+}
+
+
+template <size_t _Nb>
+inline bitset<_Nb>  _STLP_CALL
+operator|(const bitset<_Nb>& __x,
+          const bitset<_Nb>& __y) {
+  bitset<_Nb> __result(__x);
+  __result |= __y;
+  return __result;
+}
+
+template <size_t _Nb>
+inline bitset<_Nb>  _STLP_CALL
+operator^(const bitset<_Nb>& __x,
+          const bitset<_Nb>& __y) {
+  bitset<_Nb> __result(__x);
+  __result ^= __y;
+  return __result;
+}
+
+#if !defined (_STLP_USE_NO_IOSTREAMS)
+
+_STLP_END_NAMESPACE
+
+#  if !(defined (_STLP_MSVC) && (_STLP_MSVC < 1300)) && \
+      !(defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x500))
+
+#ifndef _STLP_INTERNAL_IOSFWD
+#  include <stl/_iosfwd.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _CharT, class _Traits, size_t _Nb>
+basic_istream<_CharT, _Traits>&  _STLP_CALL
+operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x);
+
+template <class _CharT, class _Traits, size_t _Nb>
+basic_ostream<_CharT, _Traits>& _STLP_CALL
+operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Nb>& __x);
+
+#  else
+
+#ifndef _STLP_STRING_IO_H
+#  include <stl/_string_io.h> //includes _istream.h and _ostream.h
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <size_t _Nb>
+istream&  _STLP_CALL
+operator>>(istream& __is, bitset<_Nb>& __x) {
+  typedef typename string::traits_type _Traits;
+  string __tmp;
+  __tmp.reserve(_Nb);
+
+  // Skip whitespace
+  typename istream::sentry __sentry(__is);
+  if (__sentry) {
+    streambuf* __buf = __is.rdbuf();
+    for (size_t __i = 0; __i < _Nb; ++__i) {
+      static typename _Traits::int_type __eof = _Traits::eof();
+
+      typename _Traits::int_type __c1 = __buf->sbumpc();
+      if (_Traits::eq_int_type(__c1, __eof)) {
+        __is.setstate(ios_base::eofbit);
+        break;
+      }
+      else {
+        typename _Traits::char_type __c2 = _Traits::to_char_type(__c1);
+        char __c  = __is.narrow(__c2, '*');
+
+        if (__c == '0' || __c == '1')
+          __tmp.push_back(__c);
+        else if (_Traits::eq_int_type(__buf->sputbackc(__c2), __eof)) {
+          __is.setstate(ios_base::failbit);
+          break;
+        }
+      }
+    }
+
+    if (__tmp.empty())
+      __is.setstate(ios_base::failbit);
+    else
+      __x._M_copy_from_string(__tmp, __STATIC_CAST(size_t,0), _Nb);
+  }
+
+  return __is;
+}
+
+template <size_t _Nb>
+ostream& _STLP_CALL
+operator<<(ostream& __os, const bitset<_Nb>& __x) {
+  string __tmp;
+  __x._M_copy_to_string(__tmp);
+  return __os << __tmp;
+}
+
+#    if !defined (_STLP_NO_WCHAR_T)
+
+template <size_t _Nb>
+wistream&  _STLP_CALL
+operator>>(wistream& __is, bitset<_Nb>& __x) {
+  typedef typename wstring::traits_type _Traits;
+  wstring __tmp;
+  __tmp.reserve(_Nb);
+
+  // Skip whitespace
+  typename wistream::sentry __sentry(__is);
+  if (__sentry) {
+    wstreambuf* __buf = __is.rdbuf();
+    for (size_t __i = 0; __i < _Nb; ++__i) {
+      static typename _Traits::int_type __eof = _Traits::eof();
+
+      typename _Traits::int_type __c1 = __buf->sbumpc();
+      if (_Traits::eq_int_type(__c1, __eof)) {
+        __is.setstate(ios_base::eofbit);
+        break;
+      }
+      else {
+        typename _Traits::char_type __c2 = _Traits::to_char_type(__c1);
+        char __c  = __is.narrow(__c2, '*');
+
+        if (__c == '0' || __c == '1')
+          __tmp.push_back(__c);
+        else if (_Traits::eq_int_type(__buf->sputbackc(__c2), __eof)) {
+          __is.setstate(ios_base::failbit);
+          break;
+        }
+      }
+    }
+
+    if (__tmp.empty())
+      __is.setstate(ios_base::failbit);
+    else
+      __x._M_copy_from_string(__tmp, __STATIC_CAST(size_t,0), _Nb);
+  }
+
+  return __is;
+}
+
+template <size_t _Nb>
+wostream& _STLP_CALL
+operator<<(wostream& __os, const bitset<_Nb>& __x) {
+  wstring __tmp;
+  __x._M_copy_to_string(__tmp);
+  return __os << __tmp;
+}
+
+#    endif /* _STLP_NO_WCHAR_T */
+#  endif
+#endif
+
+#endif /* _STLP_NON_TYPE_TMPL_PARAM_BUG */
+
+#undef  bitset
+
+_STLP_END_NAMESPACE
+
+#undef __BITS_PER_WORD
+#undef __BITSET_WORDS
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+#  include <stl/_bitset.c>
+#endif
+
+#endif /* _STLP_BITSET_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_cctype.h b/stlport/stlport/stl/_cctype.h
new file mode 100644
index 0000000..cf82524
--- /dev/null
+++ b/stlport/stlport/stl/_cctype.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_CCTYPE
+#define _STLP_INTERNAL_CCTYPE
+
+#if defined (_STLP_USE_NEW_C_HEADERS)
+#  if defined (_STLP_HAS_INCLUDE_NEXT)
+#    include_next <cctype>
+#  else
+#    include _STLP_NATIVE_CPP_C_HEADER(cctype)
+#  endif
+#else
+#  include <ctype.h>
+#endif /* _STLP_USE_NEW_C_HEADERS */
+
+#if ! defined (_STLP_NO_CSTD_FUNCTION_IMPORTS)
+#  if defined ( _STLP_IMPORT_VENDOR_CSTD )
+_STLP_BEGIN_NAMESPACE
+using _STLP_VENDOR_CSTD::isalnum;
+using _STLP_VENDOR_CSTD::isalpha;
+using _STLP_VENDOR_CSTD::iscntrl;
+using _STLP_VENDOR_CSTD::isdigit;
+using _STLP_VENDOR_CSTD::isgraph;
+using _STLP_VENDOR_CSTD::islower;
+using _STLP_VENDOR_CSTD::isprint;
+using _STLP_VENDOR_CSTD::ispunct;
+using _STLP_VENDOR_CSTD::isspace;
+using _STLP_VENDOR_CSTD::isupper;
+using _STLP_VENDOR_CSTD::isxdigit;
+using _STLP_VENDOR_CSTD::tolower;
+using _STLP_VENDOR_CSTD::toupper;
+_STLP_END_NAMESPACE
+#  endif /* _STLP_IMPORT_VENDOR_CSTD*/
+#endif /* _STLP_NO_CSTD_FUNCTION_IMPORTS */
+
+#endif
diff --git a/stlport/stlport/stl/_ctraits_fns.h b/stlport/stlport/stl/_ctraits_fns.h
new file mode 100644
index 0000000..e4a4af1
--- /dev/null
+++ b/stlport/stlport/stl/_ctraits_fns.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 1999
+ * 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.
+ */
+
+// WARNING: This is an internal header file, included by other C++
+// standard library headers.  You should not attempt to use this header
+// file directly.
+
+#ifndef _STLP_INTERNAL_CTRAITS_FUNCTIONS_H
+#define _STLP_INTERNAL_CTRAITS_FUNCTIONS_H
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+#  include <stl/_function_base.h>
+#endif
+
+// This file contains a few small adapters that allow a character
+// traits class to be used as a function object.
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Traits>
+struct _Eq_traits
+  : public binary_function<typename _Traits::char_type,
+                           typename _Traits::char_type,
+                           bool> {
+  bool operator()(const typename _Traits::char_type& __x,
+                  const typename _Traits::char_type& __y) const
+  { return _Traits::eq(__x, __y); }
+};
+
+template <class _Traits>
+struct _Eq_char_bound
+  : public unary_function<typename _Traits::char_type, bool> {
+  typename _Traits::char_type __val;
+  _Eq_char_bound(typename _Traits::char_type __c) : __val(__c) {}
+  bool operator()(const typename _Traits::char_type& __x) const
+  { return _Traits::eq(__x, __val); }
+};
+
+template <class _Traits>
+struct _Neq_char_bound
+  : public unary_function<typename _Traits::char_type, bool>
+{
+  typename _Traits::char_type __val;
+  _Neq_char_bound(typename _Traits::char_type __c) : __val(__c) {}
+  bool operator()(const typename _Traits::char_type& __x) const
+  { return !_Traits::eq(__x, __val); }
+};
+
+template <class _Traits>
+struct _Eq_int_bound
+  : public unary_function<typename _Traits::char_type, bool> {
+  typename _Traits::int_type __val;
+
+  _Eq_int_bound(typename _Traits::int_type __c) : __val(__c) {}
+  bool operator()(const typename _Traits::char_type& __x) const
+  { return _Traits::eq_int_type(_Traits::to_int_type(__x), __val); }
+};
+
+#if 0
+template <class _Traits>
+struct _Lt_traits
+  : public binary_function<typename _Traits::char_type,
+                           typename _Traits::char_type,
+                           bool> {
+  bool operator()(const typename _Traits::char_type& __x,
+                  const typename _Traits::char_type& __y) const
+  { return _Traits::lt(__x, __y); }
+};
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_CTRAITS_FUNCTIONS_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_cwchar.h b/stlport/stlport/stl/_cwchar.h
new file mode 100644
index 0000000..87cb82b
--- /dev/null
+++ b/stlport/stlport/stl/_cwchar.h
@@ -0,0 +1,342 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_CWCHAR
+#define _STLP_INTERNAL_CWCHAR
+
+#if defined (_STLP_WCE_EVC3)
+#  ifndef _STLP_INTERNAL_MBSTATE_T
+#    include <stl/_mbstate_t.h>
+#  endif
+#else
+#  if defined (__GNUC__)
+#    if defined (_STLP_HAS_INCLUDE_NEXT)
+#      include_next <cstddef>
+#    else
+#      include _STLP_NATIVE_CPP_C_HEADER(cstddef)
+#    endif
+#  endif
+
+#  if !defined (_STLP_NO_CWCHAR) && defined (_STLP_USE_NEW_C_HEADERS)
+#    if defined (_STLP_HAS_INCLUDE_NEXT)
+#      include_next <cwchar>
+#    else
+#      include _STLP_NATIVE_CPP_C_HEADER(cwchar)
+#    endif
+#    if defined (__OpenBSD__)
+typedef _BSD_WINT_T_ wint_t;
+#    endif /* __OpenBSD__ */
+
+#    if defined (__DMC__)
+#      define __STDC_LIMIT_MACROS
+#      include <stdint.h> // WCHAR_MIN, WCHAR_MAX
+#    endif
+#  elif defined (_STLP_NO_WCHAR_T) || \
+       (defined (__BORLANDC__) && (__BORLANDC__ < 0x570)) || \
+        defined (__OpenBSD__) || defined (__FreeBSD__) || \
+       (defined (__GNUC__) && (defined (__APPLE__) || defined ( __Lynx__ )))
+#    if defined (_STLP_HAS_INCLUDE_NEXT)
+#      include_next <stddef.h>
+#    else
+#      include _STLP_NATIVE_C_HEADER(stddef.h)
+#    endif
+#    if defined (__Lynx__)
+#      ifndef _WINT_T
+typedef long int wint_t;
+#        define _WINT_T
+#      endif /* _WINT_T */
+#    endif
+#    if defined(__OpenBSD__)
+typedef _BSD_WINT_T_ wint_t;
+#    endif /* __OpenBSD__ */
+#  else
+#    if defined (_STLP_HAS_INCLUDE_NEXT)
+#      include_next <wchar.h>
+#    else
+#      include _STLP_NATIVE_C_HEADER(wchar.h)
+#    endif
+
+#    if defined (__sun) && (defined (_XOPEN_SOURCE) || (_XOPEN_VERSION - 0 == 4))
+extern wint_t   btowc();
+extern int      fwprintf();
+extern int      fwscanf();
+extern int      fwide();
+extern int      mbsinit();
+extern size_t   mbrlen();
+extern size_t   mbrtowc();
+extern size_t   mbsrtowcs();
+extern int      swprintf();
+extern int      swscanf();
+extern int      vfwprintf();
+extern int      vwprintf();
+extern int      vswprintf();
+extern size_t   wcrtomb();
+extern size_t   wcsrtombs();
+extern wchar_t  *wcsstr();
+extern int      wctob();
+extern wchar_t  *wmemchr();
+extern int      wmemcmp();
+extern wchar_t  *wmemcpy();
+extern wchar_t  *wmemmove();
+extern wchar_t  *wmemset();
+extern int      wprintf();
+extern int      wscanf();
+#    endif
+#  endif
+
+#  if defined (__MSL__) && (__MSL__ <= 0x51FF)  /* dwa 2/28/99 - not yet implemented by MSL  */
+#    define _STLP_WCHAR_MSL_EXCLUDE 1
+namespace std {
+  extern "C" size_t wcsftime(wchar_t * str, size_t max_size, const wchar_t * format_str, const struct tm * timeptr);
+}
+#    define _STLP_NO_NATIVE_MBSTATE_T 1
+#  elif defined (__BORLANDC__)
+#    if !defined (_STLP_USE_NO_IOSTREAMS)
+#      define _STLP_NO_NATIVE_MBSTATE_T
+#    endif
+#    define _STLP_WCHAR_BORLAND_EXCLUDE 1
+#  endif
+
+#  ifndef _STLP_INTERNAL_MBSTATE_T
+#    include <stl/_mbstate_t.h>
+#  endif
+
+#  if !defined (_STLP_NO_WCHAR_T)
+#    ifndef WCHAR_MIN
+#      define WCHAR_MIN 0
+/* SUNpro has some bugs with casts. wchar_t is size of int there anyway. */
+#      if defined (__SUNPRO_CC) || defined (__DJGPP)
+#        define WCHAR_MAX (~0)
+#      else
+#        define WCHAR_MAX ((wchar_t)~0)
+#      endif
+#    endif
+#    if defined (__DMC__) || (defined (_STLP_MSVC_LIB) && (_STLP_MSVC_LIB < 1400)) || defined(_WIN32_WCE)
+/* Compilers that do not define WCHAR_MIN and WCHAR_MAX to be testable at
+ * preprocessing time. */
+#      undef WCHAR_MIN
+#      define WCHAR_MIN 0
+#      undef WCHAR_MAX
+#      define WCHAR_MAX 0xffff
+#    endif
+#    if defined (__GNUC__) && defined (__alpha__)
+/* Definition of WCHAR_MIN and MAX are wrong for alpha platform
+ * as gcc consider wchar_t as an unsigned type but WCHAR_MIN is defined as
+ * a negative value. Static assertion is here to check that a future alpha
+ * SDK or a future gcc won't change the situation making this workaround
+ * useless.
+ */
+/* Check that gcc still consider wchar_t as unsigned */
+_STLP_STATIC_ASSERT(((wchar_t)-1 > 0))
+/* Check that WCHAR_MIN value hasn't been fixed */
+_STLP_STATIC_ASSERT((WCHAR_MIN < 0))
+#      undef WCHAR_MIN
+#      define WCHAR_MIN 0
+#      undef WCHAR_MAX
+#      define WCHAR_MAX 0xffffffff
+#    endif
+#    if defined(__HP_aCC) && (__HP_aCC >= 60000)
+/* Starting with B.11.31, HP-UX/ia64 provides C99-compliant definitions
+ * of WCHAR_MIN/MAX macros without having to define
+ * _INCLUDE_STDC__SOURCE_199901 macro (which aCC compiler does not
+ * predefine). Let STLport provide B.11.31 definitions on any version of
+ * HP-UX/ia64.
+ */
+#      undef WCHAR_MIN
+#      define WCHAR_MIN 0
+#      undef WCHAR_MAX
+#      define WCHAR_MAX UINT_MAX
+#    endif
+#  endif
+
+#  if defined (_STLP_IMPORT_VENDOR_CSTD)
+
+#    if defined (__SUNPRO_CC) && !defined (_STLP_HAS_NO_NEW_C_HEADERS)
+using _STLP_VENDOR_CSTD::wint_t;
+#    endif
+
+_STLP_BEGIN_NAMESPACE
+#    if defined (_STLP_NO_WCHAR_T)
+typedef int wint_t;
+#    else
+// gcc 3.0 has a glitch : wint_t only sucked into the global namespace if _GLIBCPP_USE_WCHAR_T is defined
+// __MWERKS__ has definition in wchar_t.h (MSL C++), but ones differ from definition
+// in stdio.h; I prefer settings from last file.
+#      if (defined (__GNUC__) && ! defined (_GLIBCPP_USE_WCHAR_T))
+using ::wint_t;
+#      else
+using _STLP_VENDOR_CSTD::wint_t;
+#      endif
+#    endif
+
+using _STLP_VENDOR_CSTD::size_t;
+
+#    if !defined (_STLP_NO_NATIVE_MBSTATE_T) && !defined (_STLP_USE_OWN_MBSTATE_T)
+using _STLP_VENDOR_MB_NAMESPACE::mbstate_t;
+
+#      if !defined (_STLP_NO_CSTD_FUNCTION_IMPORTS) && !defined(_STLP_WCHAR_BORLAND_EXCLUDE) && \
+         (!defined(__MSL__) || __MSL__ > 0x6001)
+#        if defined (__MINGW32__) && ((__MINGW32_MAJOR_VERSION > 3) || ((__MINGW32_MAJOR_VERSION == 3) && (__MINGW32_MINOR_VERSION >= 8))) || \
+          !(defined (__KCC) || defined (__GNUC__)) && !defined(_STLP_WCE_NET)
+using _STLP_VENDOR_MB_NAMESPACE::btowc;
+#          if (!defined(__MSL__) || __MSL__ > 0x7001)
+using _STLP_VENDOR_MB_NAMESPACE::mbsinit;
+#          endif
+#        endif
+#        if defined (__MINGW32__) && ((__MINGW32_MAJOR_VERSION > 3) || ((__MINGW32_MAJOR_VERSION == 3) && (__MINGW32_MINOR_VERSION >= 8))) || \
+           !defined (__GNUC__) && !defined(_STLP_WCE_NET)
+using _STLP_VENDOR_MB_NAMESPACE::mbrlen;
+using _STLP_VENDOR_MB_NAMESPACE::mbrtowc;
+using _STLP_VENDOR_MB_NAMESPACE::mbsrtowcs;
+using _STLP_VENDOR_MB_NAMESPACE::wcrtomb;
+using _STLP_VENDOR_MB_NAMESPACE::wcsrtombs;
+#        endif
+#      endif /* BORLAND && !__MSL__ || __MSL__ > 0x6001 */
+
+#    endif /* _STLP_NO_NATIVE_MBSTATE_T */
+
+#    if !defined (_STLP_NO_NATIVE_WIDE_FUNCTIONS) && ! defined (_STLP_NO_CSTD_FUNCTION_IMPORTS)
+
+#      if !defined (_STLP_WCHAR_BORLAND_EXCLUDE) && ! defined (_STLP_NO_CSTD_FUNCTION_IMPORTS)
+using _STLP_VENDOR_CSTD::fgetwc;
+using _STLP_VENDOR_CSTD::fgetws;
+using _STLP_VENDOR_CSTD::fputwc;
+using _STLP_VENDOR_CSTD::fputws;
+#      endif
+
+#      if !(defined (_STLP_WCHAR_SUNPRO_EXCLUDE) || defined (_STLP_WCHAR_BORLAND_EXCLUDE) || \
+            defined(_STLP_WCHAR_HPACC_EXCLUDE) )
+#        if !defined (__DECCXX)
+using _STLP_VENDOR_CSTD::fwide;
+#        endif
+using _STLP_VENDOR_CSTD::fwprintf;
+using _STLP_VENDOR_CSTD::fwscanf;
+using _STLP_VENDOR_CSTD::getwchar;
+#      endif
+
+#      if !defined(_STLP_WCHAR_BORLAND_EXCLUDE)
+#        ifndef _STLP_WCE_NET
+using _STLP_VENDOR_CSTD::getwc;
+#        endif
+using _STLP_VENDOR_CSTD::ungetwc;
+#        ifndef _STLP_WCE_NET
+using _STLP_VENDOR_CSTD::putwc;
+#        endif
+using _STLP_VENDOR_CSTD::putwchar;
+#      endif
+
+#      if !(defined (_STLP_WCHAR_SUNPRO_EXCLUDE) || defined (_STLP_WCHAR_BORLAND_EXCLUDE) || \
+            defined (_STLP_WCHAR_HPACC_EXCLUDE) )
+#        if defined (_STLP_MSVC_LIB) && (_STLP_MSVC_LIB <= 1300) || \
+            defined (__MINGW32__)
+#          undef swprintf
+#          define swprintf _snwprintf
+#          undef vswprintf
+#          define vswprintf _vsnwprintf
+using ::swprintf;
+using ::vswprintf;
+#        else
+using _STLP_VENDOR_CSTD::swprintf;
+using _STLP_VENDOR_CSTD::vswprintf;
+#        endif
+using _STLP_VENDOR_CSTD::swscanf;
+using _STLP_VENDOR_CSTD::vfwprintf;
+using _STLP_VENDOR_CSTD::vwprintf;
+
+#        if (!defined(__MSL__) || __MSL__ > 0x7001 ) && !defined(_STLP_WCE_NET) && \
+             !defined(_STLP_USE_UCLIBC) /* at least in uClibc 0.9.26 */
+
+using _STLP_VENDOR_CSTD::wcsftime;
+#        endif
+using _STLP_VENDOR_CSTD::wcstok;
+
+#      endif
+
+#      if !defined (_STLP_WCE_NET)
+using _STLP_VENDOR_CSTD::wcscoll;
+using _STLP_VENDOR_CSTD::wcsxfrm;
+#      endif
+using _STLP_VENDOR_CSTD::wcscat;
+using _STLP_VENDOR_CSTD::wcsrchr;
+using _STLP_VENDOR_CSTD::wcscmp;
+
+using _STLP_VENDOR_CSTD::wcscpy;
+using _STLP_VENDOR_CSTD::wcscspn;
+
+using _STLP_VENDOR_CSTD::wcslen;
+using _STLP_VENDOR_CSTD::wcsncat;
+using _STLP_VENDOR_CSTD::wcsncmp;
+using _STLP_VENDOR_CSTD::wcsncpy;
+using _STLP_VENDOR_CSTD::wcspbrk;
+using _STLP_VENDOR_CSTD::wcschr;
+
+using _STLP_VENDOR_CSTD::wcsspn;
+
+#      if !defined (_STLP_WCHAR_BORLAND_EXCLUDE)
+using _STLP_VENDOR_CSTD::wcstod;
+using _STLP_VENDOR_CSTD::wcstol;
+#      endif
+
+#      if !(defined (_STLP_WCHAR_SUNPRO_EXCLUDE) || defined (_STLP_WCHAR_HPACC_EXCLUDE) )
+using _STLP_VENDOR_CSTD::wcsstr;
+using _STLP_VENDOR_CSTD::wmemchr;
+
+#        if !defined (_STLP_WCHAR_BORLAND_EXCLUDE)
+#            if !defined (_STLP_WCE_NET)
+using _STLP_VENDOR_CSTD::wctob;
+#            endif
+#          if !defined (__DMC__)
+using _STLP_VENDOR_CSTD::wmemcmp;
+using _STLP_VENDOR_CSTD::wmemmove;
+#          endif
+using _STLP_VENDOR_CSTD::wprintf;
+using _STLP_VENDOR_CSTD::wscanf;
+#        endif
+
+#        if defined (__BORLANDC__) && !defined (__linux__)
+inline wchar_t* _STLP_wmemcpy(wchar_t* __wdst, const wchar_t* __wsrc, size_t __n)
+{ return __STATIC_CAST(wchar_t*, _STLP_VENDOR_CSTD::wmemcpy(__wdst, __wsrc, __n)); }
+inline wchar_t* _STLP_wmemset(wchar_t* __wdst, wchar_t __wc, size_t __n)
+{ return __STATIC_CAST(wchar_t*, _STLP_VENDOR_CSTD::memset(__wdst, __wc, __n)); }
+#          undef wmemcpy
+#          undef wmemset
+inline wchar_t* wmemcpy(wchar_t* __wdst, const wchar_t* __wsrc, size_t __n)
+{ return _STLP_wmemcpy(__wdst, __wsrc, __n); }
+inline wchar_t* wmemset(wchar_t* __wdst, wchar_t __wc, size_t __n)
+{ return _STLP_wmemset(__wdst, __wc, __n); }
+#        elif defined (__DMC__)
+inline wchar_t* wmemcpy(wchar_t* __RESTRICT __wdst, const wchar_t* __RESTRICT __wsrc, size_t __n)
+{ return __STATIC_CAST(wchar_t*, memcpy(__wdst, __wsrc, __n * sizeof(wchar_t))); }
+inline wchar_t* wmemmove(wchar_t* __RESTRICT __wdst, const wchar_t * __RESTRICT __wc, size_t __n)
+{ return __STATIC_CAST(wchar_t*, memmove(__wdst, __wc, __n * sizeof(wchar_t))); }
+inline wchar_t* wmemset(wchar_t* __wdst, wchar_t __wc, size_t __n)
+{ for (size_t i = 0; i < __n; i++) __wdst[i] = __wc; return __wdst; }
+#        else
+using _STLP_VENDOR_CSTD::wmemcpy;
+using _STLP_VENDOR_CSTD::wmemset;
+#        endif
+#      endif
+
+#    endif /* _STLP_NO_NATIVE_WIDE_FUNCTIONS */
+_STLP_END_NAMESPACE
+
+#  endif /* _STLP_IMPORT_VENDOR_CSTD */
+
+#  undef _STLP_WCHAR_SUNPRO_EXCLUDE
+#  undef _STLP_WCHAR_MSL_EXCLUDE
+
+#  endif /* !defined(_STLP_WCE_EVC3) */
+
+#endif /* _STLP_INTERNAL_CWCHAR */
diff --git a/stlport/stlport/stl/_deque.c b/stlport/stlport/stl/_deque.c
new file mode 100644
index 0000000..74e9ef6
--- /dev/null
+++ b/stlport/stlport/stl/_deque.c
@@ -0,0 +1,823 @@
+/*
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_DEQUE_C
+#define _STLP_DEQUE_C
+
+#ifndef _STLP_INTERNAL_DEQUE_H
+#  include <stl/_deque.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// Non-inline member functions from _Deque_base.
+
+template <class _Tp, class _Alloc >
+_Deque_base<_Tp,_Alloc >::~_Deque_base() {
+  if (_M_map._M_data) {
+    _M_destroy_nodes(_M_start._M_node, this->_M_finish._M_node + 1);
+    _M_map.deallocate(_M_map._M_data, _M_map_size._M_data);
+  }
+}
+
+template <class _Tp, class _Alloc >
+void _Deque_base<_Tp,_Alloc>::_M_initialize_map(size_t __num_elements) {
+  size_t __num_nodes = __num_elements / this->buffer_size() + 1 ;
+
+  _M_map_size._M_data = (max)((size_t) _S_initial_map_size, __num_nodes + 2);
+  _M_map._M_data = _M_map.allocate(_M_map_size._M_data);
+
+  _Tp** __nstart = _M_map._M_data + (_M_map_size._M_data - __num_nodes) / 2;
+  _Tp** __nfinish = __nstart + __num_nodes;
+
+  _STLP_TRY {
+    _M_create_nodes(__nstart, __nfinish);
+  }
+  _STLP_UNWIND((_M_map.deallocate(_M_map._M_data, _M_map_size._M_data),
+                _M_map._M_data = 0, _M_map_size._M_data = 0))
+  _M_start._M_set_node(__nstart);
+  this->_M_finish._M_set_node(__nfinish - 1);
+  _M_start._M_cur = _M_start._M_first;
+  this->_M_finish._M_cur = this->_M_finish._M_first + __num_elements % this->buffer_size();
+}
+
+template <class _Tp, class _Alloc >
+void _Deque_base<_Tp,_Alloc>::_M_create_nodes(_Tp** __nstart,
+                                              _Tp** __nfinish) {
+  _Tp** __cur = __nstart;
+  _STLP_TRY {
+    for (; __cur < __nfinish; ++__cur)
+      *__cur = _M_map_size.allocate(this->buffer_size());
+  }
+  _STLP_UNWIND(_M_destroy_nodes(__nstart, __cur))
+}
+
+template <class _Tp, class _Alloc >
+void _Deque_base<_Tp,_Alloc>::_M_destroy_nodes(_Tp** __nstart,
+                                               _Tp** __nfinish) {
+  for (_Tp** __n = __nstart; __n < __nfinish; ++__n)
+    _M_map_size.deallocate(*__n, this->buffer_size());
+}
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+#  define deque _STLP_PTR_IMPL_NAME(deque)
+#elif defined (_STLP_DEBUG)
+#  define deque _STLP_NON_DBG_NAME(deque)
+#else
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#if defined (_STLP_NESTED_TYPE_PARAM_BUG)
+// qualified references
+#  define __iterator__   _Deque_iterator<_Tp, _Nonconst_traits<_Tp> >
+#  define const_iterator _Deque_iterator<_Tp, _Const_traits<_Tp>  >
+#  define iterator       __iterator__
+#  define size_type      size_t
+#  define value_type     _Tp
+#else
+#  define __iterator__   _STLP_TYPENAME_ON_RETURN_TYPE deque<_Tp, _Alloc>::iterator
+#endif
+
+template <class _Tp, class _Alloc >
+deque<_Tp, _Alloc >&
+deque<_Tp, _Alloc >::operator= (const deque<_Tp, _Alloc >& __x) {
+  const size_type __len = size();
+  if (&__x != this) {
+    if (__len >= __x.size())
+      erase(_STLP_STD::copy(__x.begin(), __x.end(), this->_M_start), this->_M_finish);
+    else {
+      const_iterator __mid = __x.begin() + difference_type(__len);
+      _STLP_STD::copy(__x.begin(), __mid, this->_M_start);
+      insert(this->_M_finish, __mid, __x.end());
+    }
+  }
+  return *this;
+}
+
+template <class _Tp, class _Alloc >
+void deque<_Tp, _Alloc >::_M_fill_insert(iterator __pos,
+                                         size_type __n, const value_type& __x) {
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+  typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+  if (__pos._M_cur == this->_M_start._M_cur) {
+    iterator __new_start = _M_reserve_elements_at_front(__n);
+    _STLP_TRY {
+      uninitialized_fill(__new_start, this->_M_start, __x);
+    }
+    _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+    this->_M_start = __new_start;
+  }
+  else if (__pos._M_cur == this->_M_finish._M_cur) {
+    iterator __new_finish = _M_reserve_elements_at_back(__n);
+    _STLP_TRY {
+      uninitialized_fill(this->_M_finish, __new_finish, __x);
+    }
+    _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node+1, __new_finish._M_node+1))
+    this->_M_finish = __new_finish;
+  }
+  else
+    _M_fill_insert_aux(__pos, __n, __x, _Movable());
+}
+
+#if !defined (_STLP_MEMBER_TEMPLATES)
+
+template <class _Tp, class _Alloc >
+void deque<_Tp, _Alloc>::insert(iterator __pos,
+                                const value_type* __first, const value_type* __last) {
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+  typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+  size_type __n = __last - __first;
+  if (__pos._M_cur == this->_M_start._M_cur) {
+    iterator __new_start = _M_reserve_elements_at_front(__n);
+    _STLP_TRY {
+      _STLP_PRIV __ucopy(__first, __last, __new_start);
+    }
+    _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+    this->_M_start = __new_start;
+  }
+  else if (__pos._M_cur == this->_M_finish._M_cur) {
+    iterator __new_finish = _M_reserve_elements_at_back(__n);
+    _STLP_TRY {
+      _STLP_PRIV __ucopy(__first, __last, this->_M_finish);
+    }
+    _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1,
+                                        __new_finish._M_node + 1))
+    this->_M_finish = __new_finish;
+  }
+  else
+    _M_insert_range_aux(__pos, __first, __last, __n, _Movable());
+}
+
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::insert(iterator __pos,
+                               const_iterator __first, const_iterator __last) {
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+  typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+  size_type __n = __last - __first;
+  if (__pos._M_cur == this->_M_start._M_cur) {
+    iterator __new_start = _M_reserve_elements_at_front(__n);
+    _STLP_TRY {
+      _STLP_PRIV __ucopy(__first, __last, __new_start);
+    }
+    _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+    this->_M_start = __new_start;
+  }
+  else if (__pos._M_cur == this->_M_finish._M_cur) {
+    iterator __new_finish = _M_reserve_elements_at_back(__n);
+    _STLP_TRY {
+      _STLP_PRIV __ucopy(__first, __last, this->_M_finish);
+    }
+    _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1,
+                                        __new_finish._M_node + 1))
+    this->_M_finish = __new_finish;
+  }
+  else
+    _M_insert_range_aux(__pos, __first, __last, __n, _Movable());
+}
+
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+template <class _Tp, class _Alloc >
+__iterator__ deque<_Tp,_Alloc>::_M_erase(iterator __pos,
+                                         const __true_type& /*_Movable*/) {
+  difference_type __index = __pos - this->_M_start;
+  if (size_type(__index) < this->size() >> 1) {
+    //We move the start of the deque one position to the right
+    //starting from the rightmost element to move.
+    iterator __src = __pos, __dst = __pos;
+    _STLP_STD::_Destroy(&(*__dst));
+    if (__src != this->_M_start) {
+      for (--__src; __dst != this->_M_start; --__src, --__dst) {
+        _STLP_STD::_Move_Construct(&(*__dst), *__src);
+        _STLP_STD::_Destroy_Moved(&(*__src));
+      }
+    }
+    _M_pop_front_aux();
+  }
+  else {
+    iterator __src = __pos, __dst = __pos;
+    _STLP_STD::_Destroy(&(*__dst));
+    for (++__src; __src != this->_M_finish; ++__src, ++__dst) {
+      _STLP_STD::_Move_Construct(&(*__dst), *__src);
+      _STLP_STD::_Destroy_Moved(&(*__src));
+    }
+    //Duplication of the pop_back code without the destroy which has already been done:
+    if (this->_M_finish._M_cur != this->_M_finish._M_first) {
+      --this->_M_finish._M_cur;
+    }
+    else {
+      _M_pop_back_aux();
+    }
+  }
+  return this->_M_start + __index;
+}
+
+template <class _Tp, class _Alloc >
+__iterator__ deque<_Tp,_Alloc>::_M_erase(iterator __pos,
+                                         const __false_type& /*_Movable*/) {
+  iterator __next = __pos;
+  ++__next;
+  difference_type __index = __pos - this->_M_start;
+  if (size_type(__index) < this->size() >> 1) {
+    copy_backward(this->_M_start, __pos, __next);
+    pop_front();
+  }
+  else {
+    _STLP_STD::copy(__next, this->_M_finish, __pos);
+    pop_back();
+  }
+  return this->_M_start + __index;
+}
+
+template <class _Tp, class _Alloc >
+__iterator__ deque<_Tp,_Alloc>::_M_erase(iterator __first, iterator __last,
+                                         const __true_type& /*_Movable*/) {
+  difference_type __n = __last - __first;
+  difference_type __elems_before = __first - this->_M_start;
+  if (__elems_before <= difference_type(this->size() - __n) / 2) {
+    iterator __src = __first, __dst = __last;
+    if (__src != this->_M_start) {
+      for (--__src, --__dst; (__src >= this->_M_start) && (__dst >= __first); --__src, --__dst) {
+        _STLP_STD::_Destroy(&(*__dst));
+        _STLP_STD::_Move_Construct(&(*__dst), *__src);
+      }
+      if (__dst >= __first) {
+        //There are more elements to erase than elements to move
+        _STLP_STD::_Destroy_Range(__first, ++__dst);
+        _STLP_STD::_Destroy_Moved_Range(this->_M_start, __first);
+      }
+      else {
+        //There are more elements to move than elements to erase
+        for (; __src >= this->_M_start; --__src, --__dst) {
+          _STLP_STD::_Destroy_Moved(&(*__dst));
+          _STLP_STD::_Move_Construct(&(*__dst), *__src);
+        }
+        _STLP_STD::_Destroy_Moved_Range(this->_M_start, ++__dst);
+      }
+    }
+    else {
+      _STLP_STD::_Destroy_Range(this->_M_start, __last);
+    }
+    iterator __new_start = this->_M_start + __n;
+    this->_M_destroy_nodes(this->_M_start._M_node, __new_start._M_node);
+    this->_M_start = __new_start;
+  }
+  else {
+    if (__last != this->_M_finish) {
+      iterator __src = __last, __dst = __first;
+      for (; (__src != this->_M_finish) && (__dst != __last); ++__src, ++__dst) {
+        _STLP_STD::_Destroy(&(*__dst));
+        _STLP_STD::_Move_Construct(&(*__dst), *__src);
+      }
+      if (__dst != __last) {
+        //There are more elements to erase than elements to move
+        _STLP_STD::_Destroy_Range(__dst, __last);
+        _STLP_STD::_Destroy_Moved_Range(__last, this->_M_finish);
+      }
+      else {
+        //There are more elements to move than elements to erase
+        for (; __src != this->_M_finish; ++__src, ++__dst) {
+          _STLP_STD::_Destroy_Moved(&(*__dst));
+          _STLP_STD::_Move_Construct(&(*__dst), *__src);
+        }
+        _STLP_STD::_Destroy_Moved_Range(__dst, this->_M_finish);
+      }
+    }
+    else {
+      _STLP_STD::_Destroy_Range(__first, this->_M_finish);
+    }
+    iterator __new_finish = this->_M_finish - __n;
+    this->_M_destroy_nodes(__new_finish._M_node + 1, this->_M_finish._M_node + 1);
+    this->_M_finish = __new_finish;
+  }
+  return this->_M_start + __elems_before;
+}
+
+template <class _Tp, class _Alloc >
+__iterator__ deque<_Tp,_Alloc>::_M_erase(iterator __first, iterator __last,
+                                         const __false_type& /*_Movable*/) {
+  difference_type __n = __last - __first;
+  difference_type __elems_before = __first - this->_M_start;
+  if (__elems_before <= difference_type(this->size() - __n) / 2) {
+    copy_backward(this->_M_start, __first, __last);
+    iterator __new_start = this->_M_start + __n;
+    _STLP_STD::_Destroy_Range(this->_M_start, __new_start);
+    this->_M_destroy_nodes(this->_M_start._M_node, __new_start._M_node);
+    this->_M_start = __new_start;
+  }
+  else {
+    _STLP_STD::copy(__last, this->_M_finish, __first);
+    iterator __new_finish = this->_M_finish - __n;
+    _STLP_STD::_Destroy_Range(__new_finish, this->_M_finish);
+    this->_M_destroy_nodes(__new_finish._M_node + 1, this->_M_finish._M_node + 1);
+    this->_M_finish = __new_finish;
+  }
+  return this->_M_start + __elems_before;
+}
+
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::clear() {
+  for (_Map_pointer __node = this->_M_start._M_node + 1;
+       __node < this->_M_finish._M_node;
+       ++__node) {
+    _STLP_STD::_Destroy_Range(*__node, *__node + this->buffer_size());
+    this->_M_map_size.deallocate(*__node, this->buffer_size());
+  }
+
+  if (this->_M_start._M_node != this->_M_finish._M_node) {
+    _STLP_STD::_Destroy_Range(this->_M_start._M_cur, this->_M_start._M_last);
+    _STLP_STD::_Destroy_Range(this->_M_finish._M_first, this->_M_finish._M_cur);
+    this->_M_map_size.deallocate(this->_M_finish._M_first, this->buffer_size());
+  }
+  else
+    _STLP_STD::_Destroy_Range(this->_M_start._M_cur, this->_M_finish._M_cur);
+
+  this->_M_finish = this->_M_start;
+}
+
+// Precondition: this->_M_start and this->_M_finish have already been initialized,
+// but none of the deque's elements have yet been constructed.
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_fill_initialize(const value_type& __val,
+                                           const __false_type& /*_TrivialInit*/) {
+  _Map_pointer __cur = this->_M_start._M_node;
+  _STLP_TRY {
+    for (; __cur < this->_M_finish._M_node; ++__cur)
+      uninitialized_fill(*__cur, *__cur + this->buffer_size(), __val);
+    uninitialized_fill(this->_M_finish._M_first, this->_M_finish._M_cur, __val);
+  }
+  _STLP_UNWIND(_STLP_STD::_Destroy_Range(this->_M_start, iterator(*__cur, __cur)))
+}
+
+
+// Called only if this->_M_finish._M_cur == this->_M_finish._M_last - 1.
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_push_back_aux_v(const value_type& __t) {
+  _M_reserve_map_at_back();
+  *(this->_M_finish._M_node + 1) = this->_M_map_size.allocate(this->buffer_size());
+  _STLP_TRY {
+    _Copy_Construct(this->_M_finish._M_cur, __t);
+    this->_M_finish._M_set_node(this->_M_finish._M_node + 1);
+    this->_M_finish._M_cur = this->_M_finish._M_first;
+  }
+  _STLP_UNWIND(this->_M_map_size.deallocate(*(this->_M_finish._M_node + 1),
+                                            this->buffer_size()))
+}
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+// Called only if this->_M_finish._M_cur == this->_M_finish._M_last - 1.
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_push_back_aux() {
+  _M_reserve_map_at_back();
+  *(this->_M_finish._M_node + 1) = this->_M_map_size.allocate(this->buffer_size());
+  _STLP_TRY {
+    _STLP_STD::_Construct(this->_M_finish._M_cur);
+    this->_M_finish._M_set_node(this->_M_finish._M_node + 1);
+    this->_M_finish._M_cur = this->_M_finish._M_first;
+  }
+  _STLP_UNWIND(this->_M_map_size.deallocate(*(this->_M_finish._M_node + 1),
+                                            this->buffer_size()))
+}
+#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+// Called only if this->_M_start._M_cur == this->_M_start._M_first.
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_push_front_aux_v(const value_type& __t) {
+  _M_reserve_map_at_front();
+  *(this->_M_start._M_node - 1) = this->_M_map_size.allocate(this->buffer_size());
+  _STLP_TRY {
+    this->_M_start._M_set_node(this->_M_start._M_node - 1);
+    this->_M_start._M_cur = this->_M_start._M_last - 1;
+    _Copy_Construct(this->_M_start._M_cur, __t);
+  }
+  _STLP_UNWIND((++this->_M_start,
+                this->_M_map_size.deallocate(*(this->_M_start._M_node - 1), this->buffer_size())))
+}
+
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+// Called only if this->_M_start._M_cur == this->_M_start._M_first.
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_push_front_aux() {
+  _M_reserve_map_at_front();
+  *(this->_M_start._M_node - 1) = this->_M_map_size.allocate(this->buffer_size());
+  _STLP_TRY {
+    this->_M_start._M_set_node(this->_M_start._M_node - 1);
+    this->_M_start._M_cur = this->_M_start._M_last - 1;
+    _STLP_STD::_Construct(this->_M_start._M_cur);
+  }
+  _STLP_UNWIND((++this->_M_start, this->_M_map_size.deallocate(*(this->_M_start._M_node - 1),
+                                                               this->buffer_size())))
+}
+#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+// Called only if this->_M_finish._M_cur == this->_M_finish._M_first.
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_pop_back_aux() {
+  this->_M_map_size.deallocate(this->_M_finish._M_first, this->buffer_size());
+  this->_M_finish._M_set_node(this->_M_finish._M_node - 1);
+  this->_M_finish._M_cur = this->_M_finish._M_last - 1;
+}
+
+// Note that if the deque has at least one element (a precondition for this member
+// function), and if this->_M_start._M_cur == this->_M_start._M_last, then the deque
+// must have at least two nodes.
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_pop_front_aux() {
+  if (this->_M_start._M_cur != this->_M_start._M_last - 1)
+    ++this->_M_start._M_cur;
+  else {
+    this->_M_map_size.deallocate(this->_M_start._M_first, this->buffer_size());
+    this->_M_start._M_set_node(this->_M_start._M_node + 1);
+    this->_M_start._M_cur = this->_M_start._M_first;
+  }
+}
+
+template <class _Tp, class _Alloc >
+__iterator__ deque<_Tp,_Alloc>::_M_fill_insert_aux(iterator __pos, size_type __n,
+                                                   const value_type& __x,
+                                                   const __true_type& /*_Movable*/) {
+  const difference_type __elems_before = __pos - this->_M_start;
+  size_type __length = this->size();
+  value_type __x_copy = __x;
+  if (__elems_before <= difference_type(__length / 2)) {
+    iterator __new_start = _M_reserve_elements_at_front(__n);
+    __pos = this->_M_start + __elems_before;
+    _STLP_TRY {
+      iterator __dst = __new_start;
+      iterator __src = this->_M_start;
+      for (; __src != __pos; ++__dst, ++__src) {
+        _STLP_STD::_Move_Construct(&(*__dst), *__src);
+        _STLP_STD::_Destroy_Moved(&(*__src));
+      }
+      this->_M_start = __new_start;
+      uninitialized_fill(__dst, __src, __x_copy);
+      __pos = __dst;
+    }
+    _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+  }
+  else {
+    iterator __new_finish = _M_reserve_elements_at_back(__n);
+    const difference_type __elems_after = difference_type(__length) - __elems_before;
+    __pos = this->_M_finish - __elems_after;
+    _STLP_TRY {
+      iterator __dst = __new_finish;
+      iterator __src = this->_M_finish;
+      for (--__src, --__dst; __src >= __pos; --__src, --__dst) {
+        _STLP_STD::_Move_Construct(&(*__dst), *__src);
+        _STLP_STD::_Destroy_Moved(&(*__src));
+      }
+      this->_M_finish = __new_finish;
+      uninitialized_fill(__pos, __pos + __n, __x_copy);
+    }
+    _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
+  }
+  return __pos;
+}
+
+template <class _Tp, class _Alloc >
+__iterator__ deque<_Tp,_Alloc>::_M_fill_insert_aux(iterator __pos, size_type __n,
+                                                   const value_type& __x,
+                                                   const __false_type& /*_Movable*/) {
+  const difference_type __elems_before = __pos - this->_M_start;
+  size_type __length = this->size();
+  value_type __x_copy = __x;
+  if (__elems_before <= difference_type(__length / 2)) {
+    iterator __new_start = _M_reserve_elements_at_front(__n);
+    iterator __old_start = this->_M_start;
+    __pos = this->_M_start + __elems_before;
+    _STLP_TRY {
+      if (__elems_before >= difference_type(__n)) {
+        iterator __start_n = this->_M_start + difference_type(__n);
+        _STLP_PRIV __ucopy(this->_M_start, __start_n, __new_start);
+        this->_M_start = __new_start;
+        _STLP_STD::copy(__start_n, __pos, __old_start);
+        _STLP_STD::fill(__pos - difference_type(__n), __pos, __x_copy);
+        __pos -= difference_type(__n);
+      }
+      else {
+        _STLP_PRIV __uninitialized_copy_fill(this->_M_start, __pos, __new_start,
+                                             this->_M_start, __x_copy);
+        this->_M_start = __new_start;
+        fill(__old_start, __pos, __x_copy);
+      }
+    }
+    _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+  }
+  else {
+    iterator __new_finish = _M_reserve_elements_at_back(__n);
+    iterator __old_finish = this->_M_finish;
+    const difference_type __elems_after =
+      difference_type(__length) - __elems_before;
+    __pos = this->_M_finish - __elems_after;
+    _STLP_TRY {
+      if (__elems_after > difference_type(__n)) {
+        iterator __finish_n = this->_M_finish - difference_type(__n);
+        _STLP_PRIV __ucopy(__finish_n, this->_M_finish, this->_M_finish);
+        this->_M_finish = __new_finish;
+        copy_backward(__pos, __finish_n, __old_finish);
+        fill(__pos, __pos + difference_type(__n), __x_copy);
+      }
+      else {
+        _STLP_PRIV __uninitialized_fill_copy(this->_M_finish, __pos + difference_type(__n),
+                                             __x_copy, __pos, this->_M_finish);
+        this->_M_finish = __new_finish;
+        fill(__pos, __old_finish, __x_copy);
+      }
+    }
+    _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
+  }
+  return __pos;
+}
+
+#if !defined (_STLP_MEMBER_TEMPLATES)
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_insert_range_aux(iterator __pos,
+                                            const value_type* __first, const value_type* __last,
+                                            size_type __n, const __true_type& /*_Movable*/) {
+  const difference_type __elems_before = __pos - this->_M_start;
+  size_type __length = size();
+  if (__elems_before <= difference_type(__length / 2)) {
+    iterator __new_start = _M_reserve_elements_at_front(__n);
+    __pos = this->_M_start + __elems_before;
+    _STLP_TRY {
+      iterator __dst = __new_start;
+      iterator __src = this->_M_start;
+      for (; __src != __pos; ++__dst, ++__src) {
+        _STLP_STD::_Move_Construct(&(*__dst), *__src);
+        _STLP_STD::_Destroy_Moved(&(*__src));
+      }
+      this->_M_start = __new_start;
+      _STLP_PRIV __ucopy(__first, __last, __dst);
+    }
+    _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+  }
+  else {
+    iterator __new_finish = _M_reserve_elements_at_back(__n);
+    const difference_type __elems_after = difference_type(__length) - __elems_before;
+    __pos = this->_M_finish - __elems_after;
+    _STLP_TRY {
+      iterator __dst = __new_finish;
+      iterator __src = this->_M_finish;
+      for (--__src, --__dst; __src >= __pos; --__src, --__dst) {
+        _STLP_STD::_Move_Construct(&(*__dst), *__src);
+        _STLP_STD::_Destroy_Moved(&(*__src));
+      }
+      this->_M_finish = __new_finish;
+      _STLP_PRIV __ucopy(__first, __last, __pos);
+    }
+    _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
+  }
+}
+
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_insert_range_aux(iterator __pos,
+                                            const value_type* __first, const value_type* __last,
+                                            size_type __n, const __false_type& /*_Movable*/) {
+  const difference_type __elems_before = __pos - this->_M_start;
+  size_type __length = size();
+  if (__elems_before <= difference_type(__length / 2)) {
+    iterator __new_start = _M_reserve_elements_at_front(__n);
+    iterator __old_start = this->_M_start;
+    __pos = this->_M_start + __elems_before;
+    _STLP_TRY {
+      if (__elems_before >= difference_type(__n)) {
+        iterator __start_n = this->_M_start + difference_type(__n);
+        _STLP_PRIV __ucopy(this->_M_start, __start_n, __new_start);
+        this->_M_start = __new_start;
+        _STLP_STD::copy(__start_n, __pos, __old_start);
+        _STLP_STD::copy(__first, __last, __pos - difference_type(__n));
+      }
+      else {
+        const value_type* __mid = __first + (difference_type(__n) - __elems_before);
+        _STLP_PRIV __uninitialized_copy_copy(this->_M_start, __pos, __first, __mid, __new_start);
+        this->_M_start = __new_start;
+        _STLP_STD::copy(__mid, __last, __old_start);
+      }
+    }
+    _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+  }
+  else {
+    iterator __new_finish = _M_reserve_elements_at_back(__n);
+    iterator __old_finish = this->_M_finish;
+    const difference_type __elems_after =
+      difference_type(__length) - __elems_before;
+    __pos = this->_M_finish - __elems_after;
+    _STLP_TRY {
+
+      if (__elems_after > difference_type(__n)) {
+        iterator __finish_n = this->_M_finish - difference_type(__n);
+        _STLP_PRIV __ucopy(__finish_n, this->_M_finish, this->_M_finish);
+        this->_M_finish = __new_finish;
+        _STLP_STD::copy_backward(__pos, __finish_n, __old_finish);
+        _STLP_STD::copy(__first, __last, __pos);
+      }
+      else {
+        const value_type* __mid = __first + __elems_after;
+        _STLP_PRIV __uninitialized_copy_copy(__mid, __last, __pos, this->_M_finish, this->_M_finish);
+        this->_M_finish = __new_finish;
+        _STLP_STD::copy(__first, __mid, __pos);
+      }
+    }
+    _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
+  }
+}
+
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_insert_range_aux(iterator __pos,
+                                            const_iterator __first, const_iterator __last,
+                                            size_type __n, const __true_type& /*_Movable*/) {
+  const difference_type __elems_before = __pos - this->_M_start;
+  size_type __length = size();
+  if (__elems_before <= difference_type(__length / 2)) {
+    iterator __new_start = _M_reserve_elements_at_front(__n);
+    __pos = this->_M_start + __elems_before;
+    _STLP_TRY {
+      iterator __dst = __new_start;
+      iterator __src = this->_M_start;
+      for (; __src != __pos; ++__dst, ++__src) {
+        _STLP_STD::_Move_Construct(&(*__dst), *__src);
+        _STLP_STD::_Destroy_Moved(&(*__src));
+      }
+      this->_M_start = __new_start;
+      _STLP_PRIV __ucopy(__first, __last, __dst);
+    }
+    _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+  }
+  else {
+    iterator __new_finish = _M_reserve_elements_at_back(__n);
+    const difference_type __elems_after = difference_type(__length) - __elems_before;
+    __pos = this->_M_finish - __elems_after;
+    _STLP_TRY {
+      iterator __dst = __new_finish;
+      iterator __src = this->_M_finish;
+      for (--__src, --__dst; __src >= __pos; --__src, --__dst) {
+        _STLP_STD::_Move_Construct(&(*__dst), *__src);
+        _STLP_STD::_Destroy_Moved(&(*__src));
+      }
+      this->_M_finish = __new_finish;
+      _STLP_PRIV __ucopy(__first, __last, __pos);
+    }
+    _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
+  }
+}
+
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_insert_range_aux(iterator __pos,
+                                            const_iterator __first, const_iterator __last,
+                                            size_type __n, const __false_type& /*_Movable*/) {
+  const difference_type __elems_before = __pos - this->_M_start;
+  size_type __length = size();
+  if (__elems_before < difference_type(__length / 2)) {
+    iterator __new_start = _M_reserve_elements_at_front(__n);
+    iterator __old_start = this->_M_start;
+    __pos = this->_M_start + __elems_before;
+    _STLP_TRY {
+      if (__elems_before >= difference_type(__n)) {
+        iterator __start_n = this->_M_start + __n;
+        _STLP_PRIV __ucopy(this->_M_start, __start_n, __new_start);
+        this->_M_start = __new_start;
+        _STLP_STD::copy(__start_n, __pos, __old_start);
+        _STLP_STD::copy(__first, __last, __pos - difference_type(__n));
+      }
+      else {
+        const_iterator __mid = __first + (__n - __elems_before);
+        _STLP_PRIV __uninitialized_copy_copy(this->_M_start, __pos, __first, __mid, __new_start);
+        this->_M_start = __new_start;
+        _STLP_STD::copy(__mid, __last, __old_start);
+      }
+    }
+    _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+  }
+  else {
+    iterator __new_finish = _M_reserve_elements_at_back(__n);
+    iterator __old_finish = this->_M_finish;
+    const difference_type __elems_after = __length - __elems_before;
+    __pos = this->_M_finish - __elems_after;
+    _STLP_TRY {
+      if (__elems_after > difference_type(__n)) {
+        iterator __finish_n = this->_M_finish - difference_type(__n);
+        _STLP_PRIV __ucopy(__finish_n, this->_M_finish, this->_M_finish);
+        this->_M_finish = __new_finish;
+        _STLP_STD::copy_backward(__pos, __finish_n, __old_finish);
+        _STLP_STD::copy(__first, __last, __pos);
+      }
+      else {
+        const_iterator __mid = __first + __elems_after;
+        _STLP_PRIV __uninitialized_copy_copy(__mid, __last, __pos, this->_M_finish, this->_M_finish);
+        this->_M_finish = __new_finish;
+        _STLP_STD::copy(__first, __mid, __pos);
+      }
+    }
+    _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
+  }
+}
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_new_elements_at_front(size_type __new_elems) {
+  size_type __new_nodes
+      = (__new_elems + this->buffer_size() - 1) / this->buffer_size();
+  _M_reserve_map_at_front(__new_nodes);
+  size_type __i = 1;
+  _STLP_TRY {
+    for (; __i <= __new_nodes; ++__i)
+      *(this->_M_start._M_node - __i) = this->_M_map_size.allocate(this->buffer_size());
+  }
+  _STLP_UNWIND(for (size_type __j = 1; __j < __i; ++__j)
+                 this->_M_map_size.deallocate(*(this->_M_start._M_node - __j), this->buffer_size()))
+}
+
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_new_elements_at_back(size_type __new_elems) {
+  size_type __new_nodes
+      = (__new_elems + this->buffer_size() - 1) / this->buffer_size();
+  _M_reserve_map_at_back(__new_nodes);
+  size_type __i = 1;
+  _STLP_TRY {
+    for (; __i <= __new_nodes; ++__i)
+      *(this->_M_finish._M_node + __i) = this->_M_map_size.allocate(this->buffer_size());
+  }
+  _STLP_UNWIND(for (size_type __j = 1; __j < __i; ++__j)
+                 this->_M_map_size.deallocate(*(this->_M_finish._M_node + __j), this->buffer_size()))
+}
+
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_reallocate_map(size_type __nodes_to_add,
+                                          bool __add_at_front) {
+  size_type __old_num_nodes = this->_M_finish._M_node - this->_M_start._M_node + 1;
+  size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
+
+  _Map_pointer __new_nstart;
+  if (this->_M_map_size._M_data > 2 * __new_num_nodes) {
+    __new_nstart = this->_M_map._M_data + (this->_M_map_size._M_data - __new_num_nodes) / 2
+                     + (__add_at_front ? __nodes_to_add : 0);
+    if (__new_nstart < this->_M_start._M_node)
+      _STLP_STD::copy(this->_M_start._M_node, this->_M_finish._M_node + 1, __new_nstart);
+    else
+      _STLP_STD::copy_backward(this->_M_start._M_node, this->_M_finish._M_node + 1,
+                               __new_nstart + __old_num_nodes);
+  }
+  else {
+    size_type __new_map_size =
+      this->_M_map_size._M_data + (max)((size_t)this->_M_map_size._M_data, __nodes_to_add) + 2;
+
+    _Map_pointer __new_map = this->_M_map.allocate(__new_map_size);
+    __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
+                             + (__add_at_front ? __nodes_to_add : 0);
+    _STLP_STD::copy(this->_M_start._M_node, this->_M_finish._M_node + 1, __new_nstart);
+    this->_M_map.deallocate(this->_M_map._M_data, this->_M_map_size._M_data);
+
+    this->_M_map._M_data = __new_map;
+    this->_M_map_size._M_data = __new_map_size;
+  }
+
+  this->_M_start._M_set_node(__new_nstart);
+  this->_M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
+}
+
+#if defined (deque)
+#  undef deque
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+_STLP_END_NAMESPACE
+
+#undef __iterator__
+#undef iterator
+#undef const_iterator
+#undef size_type
+#undef value_type
+
+#endif /*  _STLP_DEQUE_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_deque.h b/stlport/stlport/stl/_deque.h
new file mode 100644
index 0000000..a8faeef
--- /dev/null
+++ b/stlport/stlport/stl/_deque.h
@@ -0,0 +1,1115 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_DEQUE_H
+#define _STLP_INTERNAL_DEQUE_H
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+#  include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+#  include <stl/_alloc.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_H
+#  include <stl/_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_UNINITIALIZED_H
+#  include <stl/_uninitialized.h>
+#endif
+
+#ifndef _STLP_RANGE_ERRORS_H
+#  include <stl/_range_errors.h>
+#endif
+
+/* 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].
+ */
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp>
+struct _Deque_iterator_base {
+
+  static size_t _S_buffer_size() {
+    const size_t blocksize = _MAX_BYTES;
+    return (sizeof(_Tp) < blocksize ? (blocksize / sizeof(_Tp)) : 1);
+  }
+
+  typedef random_access_iterator_tag iterator_category;
+
+  typedef _Tp value_type;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+
+  typedef value_type** _Map_pointer;
+
+  typedef _Deque_iterator_base< _Tp > _Self;
+
+  value_type* _M_cur;
+  value_type* _M_first;
+  value_type* _M_last;
+  _Map_pointer _M_node;
+
+  _Deque_iterator_base(value_type* __x, _Map_pointer __y)
+    : _M_cur(__x), _M_first(*__y),
+      _M_last(*__y + _S_buffer_size()), _M_node(__y) {}
+
+  _Deque_iterator_base() : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) {}
+
+// see comment in doc/README.evc4 and doc/README.evc8
+#if defined (_STLP_MSVC) && (_STLP_MSVC <= 1401) && defined (MIPS) && defined (NDEBUG)
+  _Deque_iterator_base(_Deque_iterator_base const& __other)
+  : _M_cur(__other._M_cur), _M_first(__other._M_first),
+    _M_last(__other._M_last), _M_node(__other._M_node) {}
+#endif
+
+  difference_type _M_subtract(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);
+  }
+
+  void _M_increment() {
+    if (++_M_cur == _M_last) {
+      _M_set_node(_M_node + 1);
+      _M_cur = _M_first;
+    }
+  }
+
+  void _M_decrement() {
+    if (_M_cur == _M_first) {
+      _M_set_node(_M_node - 1);
+      _M_cur = _M_last;
+    }
+    --_M_cur;
+  }
+
+  void _M_advance(difference_type __n) {
+    const size_t buffersize = _S_buffer_size();
+    difference_type __offset = __n + (_M_cur - _M_first);
+    if (__offset >= 0 && __offset < difference_type(buffersize))
+      _M_cur += __n;
+    else {
+      difference_type __node_offset =
+        __offset > 0 ? __offset / buffersize
+                   : -difference_type((-__offset - 1) / buffersize) - 1;
+      _M_set_node(_M_node + __node_offset);
+      _M_cur = _M_first +
+
+        (__offset - __node_offset * difference_type(buffersize));
+    }
+  }
+
+  void _M_set_node(_Map_pointer __new_node) {
+    _M_last = (_M_first = *(_M_node = __new_node)) + difference_type(_S_buffer_size());
+  }
+};
+
+
+template <class _Tp, class _Traits>
+struct _Deque_iterator : public _Deque_iterator_base< _Tp> {
+  typedef random_access_iterator_tag iterator_category;
+  typedef _Tp value_type;
+  typedef typename _Traits::reference  reference;
+  typedef typename _Traits::pointer    pointer;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef value_type** _Map_pointer;
+
+  typedef _Deque_iterator_base< _Tp > _Base;
+  typedef _Deque_iterator<_Tp, _Traits> _Self;
+  typedef typename _Traits::_NonConstTraits     _NonConstTraits;
+  typedef _Deque_iterator<_Tp, _NonConstTraits> iterator;
+  typedef typename _Traits::_ConstTraits        _ConstTraits;
+  typedef _Deque_iterator<_Tp, _ConstTraits>    const_iterator;
+
+  _Deque_iterator(value_type* __x, _Map_pointer __y) :
+    _Deque_iterator_base<value_type>(__x,__y) {}
+
+  _Deque_iterator() {}
+  //copy constructor for iterator and constructor from iterator for const_iterator
+  _Deque_iterator(const iterator& __x) :
+    _Deque_iterator_base<value_type>(__x) {}
+
+  reference operator*() const {
+    return *this->_M_cur;
+  }
+
+  _STLP_DEFINE_ARROW_OPERATOR
+
+  difference_type operator-(const const_iterator& __x) const { return this->_M_subtract(__x); }
+
+  _Self& operator++() { this->_M_increment(); return *this; }
+  _Self operator++(int)  {
+    _Self __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
+
+  _Self& operator--() { this->_M_decrement(); return *this; }
+  _Self operator--(int) {
+    _Self __tmp = *this;
+    --*this;
+    return __tmp;
+  }
+
+  _Self& operator+=(difference_type __n) { this->_M_advance(__n); 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); }
+};
+
+
+template <class _Tp, class _Traits>
+inline _Deque_iterator<_Tp, _Traits> _STLP_CALL
+operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Traits>& __x)
+{ return __x + __n; }
+
+
+#if defined (_STLP_USE_SEPARATE_RELOPS_NAMESPACE)
+template <class _Tp>
+inline bool _STLP_CALL
+operator==(const _Deque_iterator_base<_Tp >& __x,
+           const _Deque_iterator_base<_Tp >& __y)
+{ return __x._M_cur == __y._M_cur; }
+
+template <class _Tp>
+inline bool _STLP_CALL
+operator < (const _Deque_iterator_base<_Tp >& __x,
+            const _Deque_iterator_base<_Tp >& __y) {
+  return (__x._M_node == __y._M_node) ?
+    (__x._M_cur < __y._M_cur) : (__x._M_node < __y._M_node);
+}
+
+template <class _Tp>
+inline bool _STLP_CALL
+operator!=(const _Deque_iterator_base<_Tp >& __x,
+           const _Deque_iterator_base<_Tp >& __y)
+{ return __x._M_cur != __y._M_cur; }
+
+template <class _Tp>
+inline bool _STLP_CALL
+operator>(const _Deque_iterator_base<_Tp >& __x,
+          const _Deque_iterator_base<_Tp >& __y)
+{ return __y < __x; }
+
+template <class _Tp>
+inline bool  _STLP_CALL operator>=(const _Deque_iterator_base<_Tp >& __x,
+                                   const _Deque_iterator_base<_Tp >& __y)
+{ return !(__x < __y); }
+
+template <class _Tp>
+inline bool  _STLP_CALL operator<=(const _Deque_iterator_base<_Tp >& __x,
+                                   const _Deque_iterator_base<_Tp >& __y)
+{ return !(__y < __x); }
+
+#else /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
+
+template <class _Tp, class _Traits1, class _Traits2>
+inline bool  _STLP_CALL
+operator==(const _Deque_iterator<_Tp, _Traits1 >& __x,
+           const _Deque_iterator<_Tp, _Traits2 >& __y)
+{ return __x._M_cur == __y._M_cur; }
+
+template <class _Tp, class _Traits1, class _Traits2>
+inline bool _STLP_CALL
+operator < (const _Deque_iterator<_Tp, _Traits1 >& __x,
+            const _Deque_iterator<_Tp, _Traits2 >& __y) {
+  return (__x._M_node == __y._M_node) ?
+    (__x._M_cur < __y._M_cur) : (__x._M_node < __y._M_node);
+}
+
+template <class _Tp>
+inline bool _STLP_CALL
+operator!=(const _Deque_iterator<_Tp, _Nonconst_traits<_Tp> >& __x,
+           const _Deque_iterator<_Tp, _Const_traits<_Tp> >& __y)
+{ return __x._M_cur != __y._M_cur; }
+
+template <class _Tp>
+inline bool _STLP_CALL
+operator>(const _Deque_iterator<_Tp, _Nonconst_traits<_Tp> >& __x,
+          const _Deque_iterator<_Tp, _Const_traits<_Tp> >& __y)
+{ return __y < __x; }
+
+template <class _Tp>
+inline bool  _STLP_CALL
+operator>=(const _Deque_iterator<_Tp, _Nonconst_traits<_Tp> >& __x,
+           const _Deque_iterator<_Tp, _Const_traits<_Tp> >& __y)
+{ return !(__x < __y); }
+
+template <class _Tp>
+inline bool _STLP_CALL
+operator<=(const _Deque_iterator<_Tp, _Nonconst_traits<_Tp> >& __x,
+           const _Deque_iterator<_Tp, _Const_traits<_Tp> >& __y)
+{ return !(__y < __x); }
+#endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+_STLP_MOVE_TO_STD_NAMESPACE
+template <class _Tp, class _Traits>
+struct __type_traits<_STLP_PRIV _Deque_iterator<_Tp, _Traits> > {
+  typedef __false_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 __false_type   is_POD_type;
+};
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+#if defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)
+_STLP_MOVE_TO_STD_NAMESPACE
+template <class _Tp, class _Traits> inline _Tp*  _STLP_CALL
+value_type(const _STLP_PRIV _Deque_iterator<_Tp, _Traits  >&) { return (_Tp*)0; }
+template <class _Tp, class _Traits> inline random_access_iterator_tag _STLP_CALL
+iterator_category(const _STLP_PRIV _Deque_iterator<_Tp, _Traits  >&) { return random_access_iterator_tag(); }
+template <class _Tp, class _Traits> inline ptrdiff_t* _STLP_CALL
+distance_type(const _STLP_PRIV _Deque_iterator<_Tp, _Traits  >&) { return 0; }
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+/* 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.
+ */
+
+template <class _Tp, class _Alloc>
+class _Deque_base {
+  typedef _Deque_base<_Tp, _Alloc> _Self;
+public:
+  typedef _Tp value_type;
+  _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
+  typedef _Alloc allocator_type;
+  typedef _STLP_alloc_proxy<size_t, value_type,  allocator_type> _Alloc_proxy;
+
+  typedef typename _Alloc_traits<_Tp*, _Alloc>::allocator_type _Map_alloc_type;
+  typedef _STLP_alloc_proxy<value_type**, value_type*, _Map_alloc_type> _Map_alloc_proxy;
+
+  typedef _Deque_iterator<_Tp, _Nonconst_traits<_Tp> > iterator;
+  typedef _Deque_iterator<_Tp, _Const_traits<_Tp> >    const_iterator;
+
+  static size_t _STLP_CALL buffer_size() { return _Deque_iterator_base<_Tp>::_S_buffer_size(); }
+
+  _Deque_base(const allocator_type& __a, size_t __num_elements)
+    : _M_start(), _M_finish(), _M_map(_STLP_CONVERT_ALLOCATOR(__a, _Tp*), 0),
+      _M_map_size(__a, (size_t)0)
+  { _M_initialize_map(__num_elements); }
+
+  _Deque_base(const allocator_type& __a)
+    : _M_start(), _M_finish(), _M_map(_STLP_CONVERT_ALLOCATOR(__a, _Tp*), 0),
+      _M_map_size(__a, (size_t)0) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+  _Deque_base(__move_source<_Self> src)
+    : _M_start(src.get()._M_start), _M_finish(src.get()._M_finish),
+      _M_map(__move_source<_Map_alloc_proxy>(src.get()._M_map)),
+      _M_map_size(__move_source<_Alloc_proxy>(src.get()._M_map_size)) {
+    src.get()._M_map._M_data = 0;
+    src.get()._M_map_size._M_data = 0;
+    src.get()._M_finish = src.get()._M_start;
+  }
+#endif
+
+  ~_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;
+  _Map_alloc_proxy  _M_map;
+  _Alloc_proxy      _M_map_size;
+};
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+#  define deque _STLP_PTR_IMPL_NAME(deque)
+#elif defined (_STLP_DEBUG)
+#  define deque _STLP_NON_DBG_NAME(deque)
+#else
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+template <class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Tp>) >
+class deque : protected _STLP_PRIV _Deque_base<_Tp, _Alloc>
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (deque)
+            , public __stlport_class<deque<_Tp, _Alloc> >
+#endif
+{
+  typedef _STLP_PRIV _Deque_base<_Tp, _Alloc> _Base;
+  typedef deque<_Tp, _Alloc> _Self;
+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 random_access_iterator_tag _Iterator_category;
+  _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
+  typedef typename _Base::allocator_type allocator_type;
+
+public:                         // Iterators
+  typedef typename _Base::iterator       iterator;
+  typedef typename _Base::const_iterator const_iterator;
+
+  _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS;
+
+protected:                      // Internal typedefs
+  typedef pointer* _Map_pointer;
+#if defined (_STLP_NO_MOVE_SEMANTIC)
+  typedef __false_type _Movable;
+#endif
+
+public:                         // Basic accessors
+  iterator begin() { return this->_M_start; }
+  iterator end() { return this->_M_finish; }
+  const_iterator begin() const { return const_iterator(this->_M_start); }
+  const_iterator end() const { return const_iterator(this->_M_finish); }
+
+  reverse_iterator rbegin() { return reverse_iterator(this->_M_finish); }
+  reverse_iterator rend() { return reverse_iterator(this->_M_start); }
+  const_reverse_iterator rbegin() const
+    { return const_reverse_iterator(this->_M_finish); }
+  const_reverse_iterator rend() const
+    { return const_reverse_iterator(this->_M_start); }
+
+  reference operator[](size_type __n)
+    { return this->_M_start[difference_type(__n)]; }
+  const_reference operator[](size_type __n) const
+    { return this->_M_start[difference_type(__n)]; }
+
+  void _M_range_check(size_type __n) const {
+    if (__n >= this->size())
+      __stl_throw_out_of_range("deque");
+  }
+  reference at(size_type __n)
+    { _M_range_check(__n); return (*this)[__n]; }
+  const_reference at(size_type __n) const
+    { _M_range_check(__n); return (*this)[__n]; }
+
+  reference front() { return *this->_M_start; }
+  reference back() {
+    iterator __tmp = this->_M_finish;
+    --__tmp;
+    return *__tmp;
+  }
+  const_reference front() const { return *this->_M_start; }
+  const_reference back() const {
+    const_iterator __tmp = this->_M_finish;
+    --__tmp;
+    return *__tmp;
+  }
+
+  size_type size() const { return this->_M_finish - this->_M_start; }
+  size_type max_size() const { return size_type(-1); }
+  bool empty() const { return this->_M_finish == this->_M_start; }
+  allocator_type get_allocator() const { return this->_M_map_size; }
+
+public:                         // Constructor, destructor.
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  explicit deque(const allocator_type& __a = allocator_type())
+#else
+  deque()
+    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(allocator_type(), 0) {}
+  deque(const allocator_type& __a)
+#endif
+    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__a, 0) {}
+
+  deque(const _Self& __x)
+    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__x.get_allocator(), __x.size())
+  { _STLP_PRIV __ucopy(__x.begin(), __x.end(), this->_M_start); }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+private:
+  void _M_initialize(size_type __n, const value_type& __val = _STLP_DEFAULT_CONSTRUCTED(_Tp)) {
+    typedef typename _TrivialInit<_Tp>::_Ret _TrivialInit;
+    _M_fill_initialize(__val, _TrivialInit());
+  }
+public:
+  explicit deque(size_type __n)
+    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(allocator_type(), __n)
+  { _M_initialize(__n); }
+  deque(size_type __n, const value_type& __val, const allocator_type& __a = allocator_type())
+#else
+  explicit deque(size_type __n)
+    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(allocator_type(), __n) {
+    typedef typename _TrivialInit<_Tp>::_Ret _TrivialInit;
+    _M_fill_initialize(_STLP_DEFAULT_CONSTRUCTED(_Tp), _TrivialInit());
+  }
+  deque(size_type __n, const value_type& __val)
+    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(allocator_type(), __n)
+  { _M_fill_initialize(__val, __false_type()); }
+  deque(size_type __n, const value_type& __val, const allocator_type& __a)
+#endif
+    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__a, __n)
+  { _M_fill_initialize(__val, __false_type()); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+protected:
+  template <class _Integer>
+  void _M_initialize_dispatch(_Integer __n, _Integer __x, const __true_type&) {
+    this->_M_initialize_map(__n);
+    _M_fill_initialize(__x, __false_type());
+  }
+
+  template <class _InputIter>
+  void _M_initialize_dispatch(_InputIter __first, _InputIter __last,
+                              const __false_type&) {
+    _M_range_initialize(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIter));
+  }
+
+public:
+  // 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 _STLP_ALLOCATOR_TYPE_DFL)
+    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__a) {
+    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+    _M_initialize_dispatch(__first, __last, _Integral());
+  }
+
+#  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+  template <class _InputIterator>
+  deque(_InputIterator __first, _InputIterator __last)
+    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(allocator_type()) {
+    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+    _M_initialize_dispatch(__first, __last, _Integral());
+  }
+#  endif
+
+#else
+  deque(const value_type* __first, const value_type* __last,
+        const allocator_type& __a = allocator_type() )
+    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__a, __last - __first)
+  { _STLP_PRIV __ucopy(__first, __last, this->_M_start); }
+
+  deque(const_iterator __first, const_iterator __last,
+        const allocator_type& __a = allocator_type() )
+    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__a, __last - __first)
+  { _STLP_PRIV __ucopy(__first, __last, this->_M_start); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+  deque(__move_source<_Self> src)
+    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__move_source<_Base>(src.get()))
+  {}
+#endif
+
+  ~deque()
+  { _STLP_STD::_Destroy_Range(this->_M_start, this->_M_finish); }
+
+  _Self& operator= (const _Self& __x);
+
+  void swap(_Self& __x) {
+    _STLP_STD::swap(this->_M_start, __x._M_start);
+    _STLP_STD::swap(this->_M_finish, __x._M_finish);
+    this->_M_map.swap(__x._M_map);
+    this->_M_map_size.swap(__x._M_map_size);
+  }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+  void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+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 _M_fill_assign(size_type __n, const _Tp& __val) {
+    if (__n > size()) {
+      _STLP_STD::fill(begin(), end(), __val);
+      insert(end(), __n - size(), __val);
+    }
+    else {
+      erase(begin() + __n, end());
+      _STLP_STD::fill(begin(), end(), __val);
+    }
+  }
+
+  void assign(size_type __n, const _Tp& __val) {
+    _M_fill_assign(__n, __val);
+  }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _InputIterator>
+  void assign(_InputIterator __first, _InputIterator __last) {
+    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+    _M_assign_dispatch(__first, __last, _Integral());
+  }
+
+private:                        // helper functions for assign()
+
+  template <class _Integer>
+  void _M_assign_dispatch(_Integer __n, _Integer __val,
+                          const __true_type& /*_IsIntegral*/)
+  { _M_fill_assign((size_type) __n, (_Tp) __val); }
+
+  template <class _InputIterator>
+  void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+                          const __false_type& /*_IsIntegral*/) {
+    _M_assign_aux(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIterator));
+  }
+
+  template <class _InputIter>
+  void _M_assign_aux(_InputIter __first, _InputIter __last, const 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,
+                     const forward_iterator_tag &) {
+#else
+  void assign(const value_type *__first, const value_type *__last) {
+    size_type __size = size();
+    size_type __len = __last - __first;
+    if (__len > __size) {
+      const value_type *__mid = __first + __size;
+      _STLP_STD::copy(__first, __mid, begin());
+      insert(end(), __mid, __last);
+    }
+    else {
+      erase(_STLP_STD::copy(__first, __last, begin()), end());
+    }
+  }
+  void assign(const_iterator __first, const_iterator __last) {
+    typedef const_iterator _ForwardIterator;
+#endif /* _STLP_MEMBER_TEMPLATES */
+    size_type __len = _STLP_STD::distance(__first, __last);
+    if (__len > size()) {
+      _ForwardIterator __mid = __first;
+      _STLP_STD::advance(__mid, size());
+      _STLP_STD::copy(__first, __mid, begin());
+      insert(end(), __mid, __last);
+    }
+    else {
+      erase(_STLP_STD::copy(__first, __last, begin()), end());
+    }
+  }
+
+
+public:                         // push_* and pop_*
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+  void push_back(const value_type& __t = _STLP_DEFAULT_CONSTRUCTED(_Tp)) {
+#else
+  void push_back(const value_type& __t) {
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+    if (this->_M_finish._M_cur != this->_M_finish._M_last - 1) {
+      _Copy_Construct(this->_M_finish._M_cur, __t);
+      ++this->_M_finish._M_cur;
+    }
+    else
+      _M_push_back_aux_v(__t);
+  }
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+  void push_front(const value_type& __t = _STLP_DEFAULT_CONSTRUCTED(_Tp))   {
+#else
+  void push_front(const value_type& __t)   {
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+    if (this->_M_start._M_cur != this->_M_start._M_first) {
+      _Copy_Construct(this->_M_start._M_cur - 1, __t);
+      --this->_M_start._M_cur;
+    }
+    else
+      _M_push_front_aux_v(__t);
+  }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+  void push_back() {
+    if (this->_M_finish._M_cur != this->_M_finish._M_last - 1) {
+      _STLP_STD::_Construct(this->_M_finish._M_cur);
+      ++this->_M_finish._M_cur;
+    }
+    else
+      _M_push_back_aux();
+  }
+  void push_front() {
+    if (this->_M_start._M_cur != this->_M_start._M_first) {
+      _STLP_STD::_Construct(this->_M_start._M_cur - 1);
+      --this->_M_start._M_cur;
+    }
+    else
+      _M_push_front_aux();
+  }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+  void pop_back() {
+    if (this->_M_finish._M_cur != this->_M_finish._M_first) {
+      --this->_M_finish._M_cur;
+      _STLP_STD::_Destroy(this->_M_finish._M_cur);
+    }
+    else {
+      _M_pop_back_aux();
+      _STLP_STD::_Destroy(this->_M_finish._M_cur);
+    }
+  }
+
+  void pop_front() {
+    _STLP_STD::_Destroy(this->_M_start._M_cur);
+    _M_pop_front_aux();
+  }
+
+public:                         // Insert
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+  iterator insert(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(_Tp)) {
+#else
+  iterator insert(iterator __pos, const value_type& __x) {
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+    typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+    if (__pos._M_cur == this->_M_start._M_cur) {
+      push_front(__x);
+      return this->_M_start;
+    }
+    else if (__pos._M_cur == this->_M_finish._M_cur) {
+      push_back(__x);
+      iterator __tmp = this->_M_finish;
+      --__tmp;
+      return __tmp;
+    }
+    else {
+      return _M_fill_insert_aux(__pos, 1, __x, _Movable());
+    }
+  }
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+  iterator insert(iterator __pos)
+  { return insert(__pos, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+  void insert(iterator __pos, size_type __n, const value_type& __x)
+  { _M_fill_insert(__pos, __n, __x); }
+
+protected:
+  iterator _M_fill_insert_aux(iterator __pos, size_type __n, const value_type& __x, const __true_type& /*_Movable*/);
+  iterator _M_fill_insert_aux(iterator __pos, size_type __n, const value_type& __x, const __false_type& /*_Movable*/);
+
+  void _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _Integer>
+  void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
+                          const __true_type& /*_IsIntegral*/) {
+    _M_fill_insert(__pos, (size_type) __n, (value_type) __x);
+  }
+
+  template <class _InputIterator>
+  void _M_insert_dispatch(iterator __pos,
+                          _InputIterator __first, _InputIterator __last,
+                          const __false_type& /*_IsIntegral*/) {
+    _M_insert(__pos, __first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIterator));
+  }
+
+public:
+  // 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 _IsIntegral<_InputIterator>::_Ret _Integral;
+    _M_insert_dispatch(__pos, __first, __last, _Integral());
+  }
+
+#else /* _STLP_MEMBER_TEMPLATES */
+  void _M_insert_range_aux(iterator __pos,
+                           const value_type* __first, const value_type* __last,
+                           size_type __n, const __true_type& /*_Movable*/);
+  void _M_insert_range_aux(iterator __pos,
+                           const value_type* __first, const value_type* __last,
+                           size_type __n, const __false_type& /*_Movable*/);
+  void _M_insert_range_aux(iterator __pos,
+                           const_iterator __first, const_iterator __last,
+                           size_type __n, const __true_type& /*_Movable*/);
+  void _M_insert_range_aux(iterator __pos,
+                           const_iterator __first, const_iterator __last,
+                           size_type __n, const __false_type& /*_Movable*/);
+public:
+  void insert(iterator __pos,
+              const value_type* __first, const value_type* __last);
+  void insert(iterator __pos,
+              const_iterator __first, const_iterator __last);
+
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+public:
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+  void resize(size_type __new_size,
+              const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(_Tp)) {
+#else
+  void resize(size_type __new_size, const value_type& __x) {
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+    const size_type __len = size();
+    if (__new_size < __len)
+      erase(this->_M_start + __new_size, this->_M_finish);
+    else
+      insert(this->_M_finish, __new_size - __len, __x);
+  }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+  void resize(size_type __new_size)
+  { resize(__new_size, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+protected:
+  iterator _M_erase(iterator __pos, const __true_type& /*_Movable*/);
+  iterator _M_erase(iterator __pos, const __false_type& /*_Movable*/);
+
+  iterator _M_erase(iterator __first, iterator __last, const __true_type& /*_Movable*/);
+  iterator _M_erase(iterator __first, iterator __last, const __false_type& /*_Movable*/);
+public:                         // Erase
+  iterator erase(iterator __pos) {
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+    typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+    return _M_erase(__pos, _Movable());
+  }
+  iterator erase(iterator __first, iterator __last) {
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+    typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+    if (__first == this->_M_start && __last == this->_M_finish) {
+      clear();
+      return this->_M_finish;
+    }
+    else {
+      if (__first == __last)
+        return __first;
+      return _M_erase(__first, __last, _Movable());
+    }
+  }
+  void clear();
+
+protected:                        // Internal construction/destruction
+
+  void _M_fill_initialize(const value_type& __val, const __true_type& /*_TrivialInit*/)
+  {}
+  void _M_fill_initialize(const value_type& __val, const __false_type& /*_TrivialInit*/);
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _InputIterator>
+  void _M_range_initialize(_InputIterator __first, _InputIterator __last,
+                           const input_iterator_tag &) {
+    this->_M_initialize_map(0);
+    _STLP_TRY {
+      for ( ; __first != __last; ++__first)
+        push_back(*__first);
+    }
+    _STLP_UNWIND(clear())
+  }
+  template <class _ForwardIterator>
+  void  _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
+                            const forward_iterator_tag &)  {
+   size_type __n = _STLP_STD::distance(__first, __last);
+   this->_M_initialize_map(__n);
+   _Map_pointer __cur_node = this->_M_start._M_node;
+   _STLP_TRY {
+    for (; __cur_node < this->_M_finish._M_node; ++__cur_node) {
+      _ForwardIterator __mid = __first;
+      _STLP_STD::advance(__mid, this->buffer_size());
+      _STLP_STD::uninitialized_copy(__first, __mid, *__cur_node);
+      __first = __mid;
+    }
+    _STLP_STD::uninitialized_copy(__first, __last, this->_M_finish._M_first);
+   }
+  _STLP_UNWIND(_STLP_STD::_Destroy_Range(this->_M_start, iterator(*__cur_node, __cur_node)))
+ }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+protected:                        // Internal push_* and pop_*
+
+  void _M_push_back_aux_v(const value_type&);
+  void _M_push_front_aux_v(const value_type&);
+#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+  void _M_push_back_aux();
+  void _M_push_front_aux();
+#endif /*_STLP_DONT_SUP_DFLT_PARAM !_STLP_NO_ANACHRONISMS*/
+  void _M_pop_back_aux();
+  void _M_pop_front_aux();
+
+protected:                        // Internal insert functions
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+
+  template <class _InputIterator>
+  void _M_insert(iterator __pos,
+                _InputIterator __first,
+                _InputIterator __last,
+                const input_iterator_tag &) {
+    _STLP_STD::copy(__first, __last, inserter(*this, __pos));
+  }
+
+  template <class _ForwardIterator>
+  void  _M_insert(iterator __pos,
+                  _ForwardIterator __first, _ForwardIterator __last,
+                  const forward_iterator_tag &) {
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+    typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+    size_type __n = _STLP_STD::distance(__first, __last);
+    if (__pos._M_cur == this->_M_start._M_cur) {
+      iterator __new_start = _M_reserve_elements_at_front(__n);
+      _STLP_TRY {
+        uninitialized_copy(__first, __last, __new_start);
+        this->_M_start = __new_start;
+      }
+      _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+    }
+    else if (__pos._M_cur == this->_M_finish._M_cur) {
+      iterator __new_finish = _M_reserve_elements_at_back(__n);
+      _STLP_TRY {
+        uninitialized_copy(__first, __last, this->_M_finish);
+        this->_M_finish = __new_finish;
+      }
+      _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
+    }
+    else
+      _M_insert_range_aux(__pos, __first, __last, __n, _Movable());
+  }
+
+  template <class _ForwardIterator>
+  void _M_insert_range_aux(iterator __pos,
+                           _ForwardIterator __first, _ForwardIterator __last,
+                           size_type __n, const __true_type& /*_Movable*/) {
+    const difference_type __elemsbefore = __pos - this->_M_start;
+    size_type __length = size();
+    if (__elemsbefore <= difference_type(__length / 2)) {
+      iterator __new_start = _M_reserve_elements_at_front(__n);
+      __pos = this->_M_start + __elemsbefore;
+      _STLP_TRY {
+        iterator __dst = __new_start;
+        iterator __src = this->_M_start;
+        for (; __src != __pos; ++__dst, ++__src) {
+          _STLP_STD::_Move_Construct(&(*__dst), *__src);
+          _STLP_STD::_Destroy_Moved(&(*__src));
+        }
+        this->_M_start = __new_start;
+        uninitialized_copy(__first, __last, __dst);
+      }
+      _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+    }
+    else {
+      iterator __new_finish = _M_reserve_elements_at_back(__n);
+      const difference_type __elemsafter = difference_type(__length) - __elemsbefore;
+      __pos = this->_M_finish - __elemsafter;
+      _STLP_TRY {
+        iterator __dst = __new_finish;
+        iterator __src = this->_M_finish;
+        for (--__src, --__dst; __src >= __pos; --__src, --__dst) {
+          _STLP_STD::_Move_Construct(&(*__dst), *__src);
+          _STLP_STD::_Destroy_Moved(&(*__src));
+        }
+        this->_M_finish = __new_finish;
+        uninitialized_copy(__first, __last, __pos);
+      }
+      _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
+    }
+  }
+
+  template <class _ForwardIterator>
+  void _M_insert_range_aux(iterator __pos,
+                           _ForwardIterator __first, _ForwardIterator __last,
+                           size_type __n, const __false_type& /*_Movable*/) {
+    const difference_type __elemsbefore = __pos - this->_M_start;
+    size_type __length = size();
+    if (__elemsbefore <= difference_type(__length / 2)) {
+      iterator __new_start = _M_reserve_elements_at_front(__n);
+      iterator __old_start = this->_M_start;
+      __pos = this->_M_start + __elemsbefore;
+      _STLP_TRY {
+        if (__elemsbefore >= difference_type(__n)) {
+          iterator __start_n = this->_M_start + difference_type(__n);
+          _STLP_STD::uninitialized_copy(this->_M_start, __start_n, __new_start);
+          this->_M_start = __new_start;
+          _STLP_STD::copy(__start_n, __pos, __old_start);
+          _STLP_STD::copy(__first, __last, __pos - difference_type(__n));
+        }
+        else {
+          _ForwardIterator __mid = __first;
+          _STLP_STD::advance(__mid, difference_type(__n) - __elemsbefore);
+          _STLP_PRIV __uninitialized_copy_copy(this->_M_start, __pos, __first, __mid, __new_start);
+          this->_M_start = __new_start;
+          _STLP_STD::copy(__mid, __last, __old_start);
+        }
+      }
+      _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+    }
+    else {
+      iterator __new_finish = _M_reserve_elements_at_back(__n);
+      iterator __old_finish = this->_M_finish;
+      const difference_type __elemsafter = difference_type(__length) - __elemsbefore;
+      __pos = this->_M_finish - __elemsafter;
+      _STLP_TRY {
+        if (__elemsafter > difference_type(__n)) {
+          iterator __finish_n = this->_M_finish - difference_type(__n);
+          _STLP_STD::uninitialized_copy(__finish_n, this->_M_finish, this->_M_finish);
+          this->_M_finish = __new_finish;
+          _STLP_STD::copy_backward(__pos, __finish_n, __old_finish);
+          _STLP_STD::copy(__first, __last, __pos);
+        }
+        else {
+          _ForwardIterator __mid = __first;
+          _STLP_STD::advance(__mid, __elemsafter);
+          _STLP_PRIV __uninitialized_copy_copy(__mid, __last, __pos, this->_M_finish, this->_M_finish);
+          this->_M_finish = __new_finish;
+          _STLP_STD::copy(__first, __mid, __pos);
+        }
+      }
+      _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
+    }
+  }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+  iterator _M_reserve_elements_at_front(size_type __n) {
+    size_type __vacancies = this->_M_start._M_cur - this->_M_start._M_first;
+    if (__n > __vacancies)
+      _M_new_elements_at_front(__n - __vacancies);
+    return this->_M_start - difference_type(__n);
+  }
+
+  iterator _M_reserve_elements_at_back(size_type __n) {
+    size_type __vacancies = (this->_M_finish._M_last - this->_M_finish._M_cur) - 1;
+    if (__n > __vacancies)
+      _M_new_elements_at_back(__n - __vacancies);
+    return this->_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 > this->_M_map_size._M_data - (this->_M_finish._M_node - this->_M_map._M_data))
+      _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(this->_M_start._M_node - this->_M_map._M_data))
+      _M_reallocate_map(__nodes_to_add, true);
+  }
+
+  void _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front);
+};
+
+#if defined (deque)
+#  undef deque
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+#  include <stl/_deque.c>
+#endif
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+#  include <stl/pointers/_deque.h>
+#endif
+
+#if defined (_STLP_DEBUG)
+#  include <stl/debug/_deque.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#define _STLP_TEMPLATE_CONTAINER deque<_Tp, _Alloc>
+#define _STLP_TEMPLATE_HEADER    template <class _Tp, class _Alloc>
+#include <stl/_relops_cont.h>
+#undef _STLP_TEMPLATE_CONTAINER
+#undef _STLP_TEMPLATE_HEADER
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Tp, class _Alloc>
+struct __move_traits<deque<_Tp, _Alloc> > {
+  typedef __true_type implemented;
+  typedef typename __move_traits<_Alloc>::complete complete;
+};
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_DEQUE_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/stlport/stlport/stl/_exception.h b/stlport/stlport/stl/_exception.h
new file mode 100644
index 0000000..a0bf4ad
--- /dev/null
+++ b/stlport/stlport/stl/_exception.h
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+// The header <exception> contains low-level functions that interact
+// with a compiler's exception-handling mechanism.  It is assumed to
+// be supplied with the compiler, rather than with the library, because
+// it is inherently tied very closely to the compiler itself.
+
+// On platforms where <exception> does not exist, this header defines
+// an exception base class.  This is *not* a substitute for everything
+// in <exception>, but it suffices to support a bare minimum of STL
+// functionality.
+
+#ifndef _STLP_INTERNAL_EXCEPTION
+#define _STLP_INTERNAL_EXCEPTION
+
+#if !defined (_STLP_NO_EXCEPTION_HEADER)
+
+#  if defined ( _UNCAUGHT_EXCEPTION )
+#    undef _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT
+#  endif
+
+#  if defined (_STLP_BROKEN_EXCEPTION_CLASS)
+#    define exception     _STLP_NULLIFIED_BROKEN_EXCEPTION_CLASS
+#    define bad_exception _STLP_NULLIFIED_BROKEN_BAD_EXCEPTION_CLASS
+#    if defined (_STLP_NO_NEW_NEW_HEADER)
+#      include _STLP_NATIVE_CPP_RUNTIME_HEADER(Exception.h)
+#    else
+#      include _STLP_NATIVE_CPP_RUNTIME_HEADER(Exception)
+#    endif
+#    undef exception
+#    undef bad_exception
+#  else
+#    if defined (_STLP_NO_NEW_NEW_HEADER)
+#      if defined (_STLP_HAS_INCLUDE_NEXT)
+#        include_next <exception.h>
+#      else
+#        include _STLP_NATIVE_CPP_RUNTIME_HEADER(exception.h)
+#      endif
+#    else
+#      if defined (_STLP_HAS_INCLUDE_NEXT)
+#        include_next <exception>
+#      else
+#        include _STLP_NATIVE_CPP_RUNTIME_HEADER(exception)
+#      endif
+#    endif
+#  endif
+
+#  if defined (_STLP_HAS_SPECIFIC_PROLOG_EPILOG) && defined (_STLP_MSVC_LIB) && (_STLP_MSVC_LIB < 1300)
+// dwa 02/04/00
+// The header <yvals.h> which ships with vc6 and is included by its native <exception>
+// actually turns on warnings, so we have to turn them back off.
+#    include <stl/config/_warnings_off.h>
+#  endif
+
+#  if defined (_STLP_USE_OWN_NAMESPACE)
+
+_STLP_BEGIN_NAMESPACE
+#    if !defined (_STLP_BROKEN_EXCEPTION_CLASS)
+#      if !defined (_STLP_USING_PLATFORM_SDK_COMPILER) || !defined (_WIN64)
+using _STLP_VENDOR_EXCEPT_STD::exception;
+#      else
+using ::exception;
+#      endif
+using _STLP_VENDOR_EXCEPT_STD::bad_exception;
+#    endif
+
+#    if !defined (_STLP_NO_USING_FOR_GLOBAL_FUNCTIONS)
+// fbp : many platforms present strange mix of
+// those in various namespaces
+#      if !defined (_STLP_VENDOR_UNEXPECTED_STD)
+#        define _STLP_VENDOR_UNEXPECTED_STD _STLP_VENDOR_EXCEPT_STD
+#      else
+/* The following definitions are for backward compatibility as _STLP_VENDOR_TERMINATE_STD
+ * and _STLP_VENDOR_UNCAUGHT_EXCEPTION_STD has been introduce after _STLP_VENDOR_UNEXPECTED_STD
+ * and _STLP_VENDOR_UNEXPECTED_STD was the macro used in their place before that introduction.
+ */
+#        if !defined (_STLP_VENDOR_TERMINATE_STD)
+#          define _STLP_VENDOR_TERMINATE_STD _STLP_VENDOR_UNEXPECTED_STD
+#        endif
+#        if !defined (_STLP_VENDOR_UNCAUGHT_EXCEPTION_STD)
+#          define _STLP_VENDOR_UNCAUGHT_EXCEPTION_STD _STLP_VENDOR_UNEXPECTED_STD
+#        endif
+#      endif
+#      if !defined (_STLP_VENDOR_TERMINATE_STD)
+#        define _STLP_VENDOR_TERMINATE_STD _STLP_VENDOR_EXCEPT_STD
+#      endif
+#      if !defined (_STLP_VENDOR_UNCAUGHT_EXCEPTION_STD)
+#        define _STLP_VENDOR_UNCAUGHT_EXCEPTION_STD _STLP_VENDOR_EXCEPT_STD
+#      endif
+#      if !defined (_STLP_VENDOR_TERMINATE_STD)
+#        define _STLP_VENDOR_TERMINATE_STD _STLP_VENDOR_EXCEPT_STD
+#      endif
+#      if !defined (_STLP_VENDOR_UNCAUGHT_EXCEPTION_STD)
+#        define _STLP_VENDOR_UNCAUGHT_EXCEPTION_STD _STLP_VENDOR_EXCEPT_STD
+#      endif
+// weird errors
+#        if !defined (_STLP_NO_UNEXPECTED_EXCEPT_SUPPORT)
+#          if defined (__ICL) && (__ICL >= 900) && (_STLP_MSVC_LIB < 1300)
+//See config/_intel.h for reason about this workaround
+using std::unexpected;
+#          else
+using _STLP_VENDOR_UNEXPECTED_STD::unexpected;
+#          endif
+using _STLP_VENDOR_UNEXPECTED_STD::unexpected_handler;
+using _STLP_VENDOR_UNEXPECTED_STD::set_unexpected;
+#        endif
+using _STLP_VENDOR_TERMINATE_STD::terminate;
+using _STLP_VENDOR_TERMINATE_STD::terminate_handler;
+using _STLP_VENDOR_TERMINATE_STD::set_terminate;
+
+#      if !defined (_STLP_NO_UNCAUGHT_EXCEPT_SUPPORT)
+using _STLP_VENDOR_UNCAUGHT_EXCEPTION_STD::uncaught_exception;
+#      endif
+#    endif /* !_STLP_NO_USING_FOR_GLOBAL_FUNCTIONS */
+_STLP_END_NAMESPACE
+#  endif /* _STLP_OWN_NAMESPACE */
+#else /* _STLP_NO_EXCEPTION_HEADER */
+
+/* fbp : absence of <exception> usually means that those
+ * functions are not going to be called by compiler.
+ * Still, define them for the user.
+ * dums: Policy modification, if the function do not behave like the Standard
+ *       defined it we do not grant it in the STLport namespace. We will have
+ *       compile time error rather than runtime error.
+ */
+#if 0
+/*
+typedef void (*unexpected_handler)();
+unexpected_handler set_unexpected(unexpected_handler f) _STLP_NOTHROW_INHERENTLY;
+void unexpected();
+
+typedef void (*terminate_handler)();
+terminate_handler set_terminate(terminate_handler f) _STLP_NOTHROW_INHERENTLY;
+void terminate();
+
+bool uncaught_exception(); // not implemented under mpw as of Jan/1999
+*/
+#endif
+
+#endif /* _STLP_NO_EXCEPTION_HEADER */
+
+#if defined (_STLP_NO_EXCEPTION_HEADER) || defined (_STLP_BROKEN_EXCEPTION_CLASS)
+_STLP_BEGIN_NAMESPACE
+
+// section 18.6.1
+class _STLP_CLASS_DECLSPEC exception {
+public:
+#  ifndef _STLP_USE_NO_IOSTREAMS
+  exception() _STLP_NOTHROW;
+  virtual ~exception() _STLP_NOTHROW;
+  virtual const char* what() const _STLP_NOTHROW;
+#  else
+  exception() _STLP_NOTHROW {}
+  virtual ~exception() _STLP_NOTHROW {}
+  virtual const char* what() const _STLP_NOTHROW {return "class exception";}
+#  endif
+};
+
+// section 18.6.2.1
+class _STLP_CLASS_DECLSPEC bad_exception : public exception {
+public:
+#  ifndef _STLP_USE_NO_IOSTREAMS
+  bad_exception() _STLP_NOTHROW;
+  ~bad_exception() _STLP_NOTHROW;
+  const char* what() const _STLP_NOTHROW;
+#  else
+  bad_exception() _STLP_NOTHROW {}
+  ~bad_exception() _STLP_NOTHROW {}
+  const char* what() const _STLP_NOTHROW {return "class bad_exception";}
+#  endif
+};
+
+// forward declaration
+class __Named_exception;
+_STLP_END_NAMESPACE
+#endif
+
+#endif /* _STLP_INTERNAL_EXCEPTION */
diff --git a/stlport/stlport/stl/_function.h b/stlport/stlport/stl/_function.h
new file mode 100644
index 0000000..bf4ad3e
--- /dev/null
+++ b/stlport/stlport/stl/_function.h
@@ -0,0 +1,433 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_FUNCTION_H
+#define _STLP_INTERNAL_FUNCTION_H
+
+#ifndef _STLP_TYPE_TRAITS_H
+#  include <stl/type_traits.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+#  include <stl/_function_base.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+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 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 divides : public binary_function<_Tp, _Tp, _Tp> {
+  _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x / __y; }
+};
+
+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 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; }
+};
+
+#if !defined (_STLP_NO_EXTENSIONS)
+// 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); }
+#endif
+
+#if defined (_STLP_BASE_TYPEDEF_BUG)
+// this workaround is needed for SunPro 4.0.1
+// suggested by "Martin Abernethy" <gma@paston.co.uk>:
+
+// We have to introduce the XXary_predicate_aux structures in order to
+// access the argument and return types of predicate functions supplied
+// as type parameters. SUN C++ 4.0.1 compiler gives errors for template type parameters
+// of the form 'name1::name2', where name1 is itself a type parameter.
+template <class _Pair>
+struct __pair_aux : private _Pair {
+  typedef typename _Pair::first_type first_type;
+  typedef typename _Pair::second_type second_type;
+};
+
+template <class _Operation>
+struct __unary_fun_aux : private _Operation {
+  typedef typename _Operation::argument_type argument_type;
+  typedef typename _Operation::result_type result_type;
+};
+
+template <class _Operation>
+struct __binary_fun_aux  : private _Operation {
+  typedef typename _Operation::first_argument_type first_argument_type;
+  typedef typename _Operation::second_argument_type second_argument_type;
+  typedef typename _Operation::result_type result_type;
+};
+
+#  define __UNARY_ARG(__Operation,__type)  __unary_fun_aux<__Operation>::__type
+#  define __BINARY_ARG(__Operation,__type)  __binary_fun_aux<__Operation>::__type
+#  define __PAIR_ARG(__Pair,__type)  __pair_aux<__Pair>::__type
+#else
+#  define __UNARY_ARG(__Operation,__type)  __Operation::__type
+#  define __BINARY_ARG(__Operation,__type) __Operation::__type
+#  define __PAIR_ARG(__Pair,__type) __Pair::__type
+#endif
+
+template <class _Predicate>
+class unary_negate
+    : public unary_function<typename __UNARY_ARG(_Predicate, argument_type), bool> {
+  typedef unary_function<typename __UNARY_ARG(_Predicate, argument_type), bool> _Base;
+public:
+  typedef typename _Base::argument_type argument_type;
+private:
+  typedef typename __call_traits<argument_type>::const_param_type _ArgParamType;
+protected:
+  _Predicate _M_pred;
+public:
+  explicit unary_negate(const _Predicate& __x) : _M_pred(__x) {}
+  bool operator()(_ArgParamType __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 __BINARY_ARG(_Predicate, first_argument_type),
+                             typename __BINARY_ARG(_Predicate, second_argument_type),
+                             bool> {
+  typedef binary_function<typename __BINARY_ARG(_Predicate, first_argument_type),
+                          typename __BINARY_ARG(_Predicate, second_argument_type),
+                          bool> _Base;
+public:
+  typedef typename _Base::first_argument_type first_argument_type;
+  typedef typename _Base::second_argument_type second_argument_type;
+private:
+  typedef typename __call_traits<first_argument_type>::const_param_type _FstArgParamType;
+  typedef typename __call_traits<second_argument_type>::const_param_type _SndArgParamType;
+protected:
+  _Predicate _M_pred;
+public:
+  explicit binary_negate(const _Predicate& __x) : _M_pred(__x) {}
+  bool operator()(_FstArgParamType __x, _SndArgParamType __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 __BINARY_ARG(_Operation, second_argument_type),
+                          typename __BINARY_ARG(_Operation, result_type) > {
+  typedef unary_function<typename __BINARY_ARG(_Operation, second_argument_type),
+                         typename __BINARY_ARG(_Operation, result_type) > _Base;
+public:
+  typedef typename _Base::argument_type argument_type;
+  typedef typename _Base::result_type result_type;
+private:
+  typedef typename __call_traits<argument_type>::param_type _ArgParamType;
+  typedef typename __call_traits<argument_type>::const_param_type _ConstArgParamType;
+  typedef typename __call_traits<typename _Operation::first_argument_type>::const_param_type _ValueParamType;
+protected:
+  //op is a Standard name (20.3.6.1), do no make it STLport naming convention compliant.
+  _Operation op;
+  typename _Operation::first_argument_type _M_value;
+public:
+  binder1st(const _Operation& __x, _ValueParamType __y)
+    : op(__x), _M_value(__y) {}
+
+  result_type operator()(_ConstArgParamType __x) const
+  { return op(_M_value, __x); }
+  // DR 109 Missing binders for non-const sequence elements
+  result_type operator()(_ArgParamType __x) const
+  { return op(_M_value, __x); }
+};
+
+template <class _Operation, class _Tp>
+inline binder1st<_Operation>
+bind1st(const _Operation& __fn, const _Tp& __x) {
+  typedef typename _Operation::first_argument_type _Arg1_type;
+  return binder1st<_Operation>(__fn, _Arg1_type(__x));
+}
+
+template <class _Operation>
+class binder2nd
+  : public unary_function<typename __BINARY_ARG(_Operation, first_argument_type),
+                          typename __BINARY_ARG(_Operation, result_type)> {
+  typedef unary_function<typename __BINARY_ARG(_Operation, first_argument_type),
+                         typename __BINARY_ARG(_Operation, result_type)> _Base;
+public:
+  typedef typename _Base::argument_type argument_type;
+  typedef typename _Base::result_type result_type;
+private:
+  typedef typename __call_traits<argument_type>::param_type _ArgParamType;
+  typedef typename __call_traits<argument_type>::const_param_type _ConstArgParamType;
+  typedef typename __call_traits<typename _Operation::second_argument_type>::const_param_type _ValueParamType;
+protected:
+  //op is a Standard name (20.3.6.3), do no make it STLport naming convention compliant.
+  _Operation op;
+  typename _Operation::second_argument_type value;
+public:
+  binder2nd(const _Operation& __x, _ValueParamType __y)
+      : op(__x), value(__y) {}
+
+  result_type operator()(_ConstArgParamType __x) const
+  { return op(__x, value); }
+  // DR 109 Missing binders for non-const sequence elements
+  result_type operator()(_ArgParamType __x) const
+  { return op(__x, value); }
+};
+
+template <class _Operation, class _Tp>
+inline binder2nd<_Operation>
+bind2nd(const _Operation& __fn, const _Tp& __x) {
+  typedef typename _Operation::second_argument_type _Arg2_type;
+  return binder2nd<_Operation>(__fn, _Arg2_type(__x));
+}
+
+#if !defined (_STLP_NO_EXTENSIONS)
+// unary_compose and binary_compose (extensions, not part of the standard).
+
+template <class _Operation1, class _Operation2>
+class unary_compose :
+  public unary_function<typename __UNARY_ARG(_Operation2, argument_type),
+                        typename __UNARY_ARG(_Operation1, result_type)> {
+  typedef unary_function<typename __UNARY_ARG(_Operation2, argument_type),
+                         typename __UNARY_ARG(_Operation1, result_type)> _Base;
+public:
+  typedef typename _Base::argument_type argument_type;
+  typedef typename _Base::result_type result_type;
+private:
+  typedef typename __call_traits<argument_type>::const_param_type _ArgParamType;
+protected:
+  _Operation1 _M_fn1;
+  _Operation2 _M_fn2;
+public:
+  unary_compose(const _Operation1& __x, const _Operation2& __y)
+    : _M_fn1(__x), _M_fn2(__y) {}
+
+  result_type operator()(_ArgParamType __x) const {
+    return _M_fn1(_M_fn2(__x));
+  }
+};
+
+template <class _Operation1, class _Operation2>
+inline unary_compose<_Operation1,_Operation2>
+compose1(const _Operation1& __fn1, const _Operation2& __fn2) {
+  return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);
+}
+
+template <class _Operation1, class _Operation2, class _Operation3>
+class binary_compose :
+    public unary_function<typename __UNARY_ARG(_Operation2, argument_type),
+                          typename __BINARY_ARG(_Operation1, result_type)> {
+  typedef unary_function<typename __UNARY_ARG(_Operation2, argument_type),
+                         typename __BINARY_ARG(_Operation1, result_type)> _Base;
+public:
+  typedef typename _Base::argument_type argument_type;
+  typedef typename _Base::result_type result_type;
+private:
+  typedef typename __call_traits<argument_type>::const_param_type _ArgParamType;
+protected:
+  _Operation1 _M_fn1;
+  _Operation2 _M_fn2;
+  _Operation3 _M_fn3;
+public:
+  binary_compose(const _Operation1& __x, const _Operation2& __y,
+                 const _Operation3& __z)
+    : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { }
+
+  result_type operator()(_ArgParamType __x) const {
+    return _M_fn1(_M_fn2(__x), _M_fn3(__x));
+  }
+};
+
+template <class _Operation1, class _Operation2, class _Operation3>
+inline binary_compose<_Operation1, _Operation2, _Operation3>
+compose2(const _Operation1& __fn1, const _Operation2& __fn2,
+         const _Operation3& __fn3) {
+  return binary_compose<_Operation1,_Operation2,_Operation3>(__fn1, __fn2, __fn3);
+}
+
+// identity is an extension: it is not part of the standard.
+template <class _Tp> struct identity : public _STLP_PRIV _Identity<_Tp> {};
+// select1st and select2nd are extensions: they are not part of the standard.
+template <class _Pair> struct select1st : public _STLP_PRIV _Select1st<_Pair> {};
+template <class _Pair> struct select2nd : public _STLP_PRIV _Select2nd<_Pair> {};
+
+template <class _Arg1, class _Arg2>
+struct project1st : public _STLP_PRIV _Project1st<_Arg1, _Arg2> {};
+
+template <class _Arg1, class _Arg2>
+struct project2nd : public _STLP_PRIV _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.)
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Result>
+struct _Constant_void_fun {
+  typedef _Result result_type;
+  result_type _M_val;
+
+  _Constant_void_fun(const result_type& __v) : _M_val(__v) {}
+  const result_type& operator()() const { return _M_val; }
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _Result>
+struct constant_void_fun : public _STLP_PRIV _Constant_void_fun<_Result> {
+  constant_void_fun(const _Result& __v)
+    : _STLP_PRIV _Constant_void_fun<_Result>(__v) {}
+};
+
+template <class _Result, _STLP_DFL_TMPL_PARAM( _Argument , _Result) >
+struct constant_unary_fun : public _STLP_PRIV _Constant_unary_fun<_Result, _Argument> {
+  constant_unary_fun(const _Result& __v)
+    : _STLP_PRIV _Constant_unary_fun<_Result, _Argument>(__v) {}
+};
+
+template <class _Result, _STLP_DFL_TMPL_PARAM( _Arg1 , _Result), _STLP_DFL_TMPL_PARAM( _Arg2 , _Arg1) >
+struct constant_binary_fun
+  : public _STLP_PRIV _Constant_binary_fun<_Result, _Arg1, _Arg2> {
+  constant_binary_fun(const _Result& __v)
+    : _STLP_PRIV _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {}
+};
+
+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<_STLP_UINT32_T, _STLP_UINT32_T> {
+private:
+  _STLP_UINT32_T _M_table[55];
+  _STLP_UINT32_T _M_index1;
+  _STLP_UINT32_T _M_index2;
+public:
+  _STLP_UINT32_T operator()(_STLP_UINT32_T __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(_STLP_UINT32_T __seed) {
+    _STLP_UINT32_T __k = 1;
+    _M_table[54] = __seed;
+    _STLP_UINT32_T __i;
+    for (__i = 0; __i < 54; __i++) {
+        _STLP_UINT32_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(161803398ul); }
+};
+
+#endif /* _STLP_NO_EXTENSIONS */
+
+_STLP_END_NAMESPACE
+
+#include <stl/_function_adaptors.h>
+
+#endif /* _STLP_INTERNAL_FUNCTION_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_function_adaptors.h b/stlport/stlport/stl/_function_adaptors.h
new file mode 100644
index 0000000..0da419b
--- /dev/null
+++ b/stlport/stlport/stl/_function_adaptors.h
@@ -0,0 +1,783 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * Copyright (c) 2000
+ * Pavel Kuznetsov
+ *
+ * Copyright (c) 2001
+ * Meridian'93
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+// This file has noo macro protection as it is meant to be included several times
+// from other header.
+// 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.
+
+_STLP_BEGIN_NAMESPACE
+
+//This implementation will only be used if needed, that is to say when there is the return void bug
+//and when there is no partial template specialization
+#if defined (_STLP_DONT_RETURN_VOID) && defined (_STLP_NO_CLASS_PARTIAL_SPECIALIZATION) && defined (_STLP_MEMBER_TEMPLATE_CLASSES)
+
+template<class _Result, class _Tp>
+class _Mem_fun0_ptr : public unary_function<_Tp*, _Result> {
+protected:
+  typedef _Result (_Tp::*__fun_type) ();
+  explicit _Mem_fun0_ptr(__fun_type __f) : _M_f(__f) {}
+
+public:
+  _Result operator ()(_Tp* __p) const { return (__p->*_M_f)(); }
+
+private:
+  __fun_type _M_f;
+};
+
+template<class _Result, class _Tp, class _Arg>
+class _Mem_fun1_ptr : public binary_function<_Tp*,_Arg,_Result> {
+protected:
+  typedef _Result (_Tp::*__fun_type) (_Arg);
+  explicit _Mem_fun1_ptr(__fun_type __f) : _M_f(__f) {}
+
+public:
+  _Result operator ()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); }
+
+private:
+  __fun_type _M_f;
+};
+
+template<class _Result, class _Tp>
+class _Const_mem_fun0_ptr : public unary_function<const _Tp*,_Result> {
+protected:
+  typedef _Result (_Tp::*__fun_type) () const;
+  explicit _Const_mem_fun0_ptr(__fun_type __f) : _M_f(__f) {}
+
+public:
+  _Result operator ()(const _Tp* __p) const { return (__p->*_M_f)(); }
+
+private:
+  __fun_type _M_f;
+};
+
+template<class _Result, class _Tp, class _Arg>
+class _Const_mem_fun1_ptr : public binary_function<const _Tp*,_Arg,_Result> {
+protected:
+  typedef _Result (_Tp::*__fun_type) (_Arg) const;
+  explicit _Const_mem_fun1_ptr(__fun_type __f) : _M_f(__f) {}
+
+public:
+  _Result operator ()(const _Tp* __p, _Arg __x) const {
+    return (__p->*_M_f)(__x); }
+
+private:
+  __fun_type _M_f;
+};
+
+template<class _Result, class _Tp>
+class _Mem_fun0_ref : public unary_function<_Tp,_Result> {
+protected:
+  typedef _Result (_Tp::*__fun_type) ();
+  explicit _Mem_fun0_ref(__fun_type __f) : _M_f(__f) {}
+
+public:
+  _Result operator ()(_Tp& __p) const { return (__p.*_M_f)(); }
+
+private:
+  __fun_type _M_f;
+};
+
+template<class _Result, class _Tp, class _Arg>
+class _Mem_fun1_ref : public binary_function<_Tp,_Arg,_Result> {
+protected:
+  typedef _Result (_Tp::*__fun_type) (_Arg);
+  explicit _Mem_fun1_ref(__fun_type __f) : _M_f(__f) {}
+
+public:
+  _Result operator ()(_Tp& __p, _Arg __x) const { return (__p.*_M_f)(__x); }
+
+private:
+  __fun_type _M_f;
+};
+
+template<class _Result, class _Tp>
+class _Const_mem_fun0_ref : public unary_function<_Tp,_Result> {
+protected:
+  typedef _Result (_Tp::*__fun_type) () const;
+  explicit _Const_mem_fun0_ref(__fun_type __f) : _M_f(__f) {}
+
+public:
+  _Result operator ()(const _Tp& __p) const { return (__p.*_M_f)(); }
+
+private:
+  __fun_type _M_f;
+};
+
+template<class _Result, class _Tp, class _Arg>
+class _Const_mem_fun1_ref : public binary_function<_Tp,_Arg,_Result> {
+protected:
+  typedef _Result (_Tp::*__fun_type) (_Arg) const;
+  explicit _Const_mem_fun1_ref(__fun_type __f) : _M_f(__f) {}
+
+public:
+  _Result operator ()(const _Tp& __p, _Arg __x) const { return (__p.*_M_f)(__x); }
+
+private:
+  __fun_type _M_f;
+};
+
+template<class _Result>
+struct _Mem_fun_traits {
+  template<class _Tp>
+  struct _Args0 {
+    typedef _Mem_fun0_ptr<_Result,_Tp>            _Ptr;
+    typedef _Const_mem_fun0_ptr<_Result,_Tp>      _Ptr_const;
+    typedef _Mem_fun0_ref<_Result,_Tp>            _Ref;
+    typedef _Const_mem_fun0_ref<_Result,_Tp>      _Ref_const;
+  };
+
+  template<class _Tp, class _Arg>
+  struct _Args1 {
+    typedef _Mem_fun1_ptr<_Result,_Tp,_Arg>       _Ptr;
+    typedef _Const_mem_fun1_ptr<_Result,_Tp,_Arg> _Ptr_const;
+    typedef _Mem_fun1_ref<_Result,_Tp,_Arg>       _Ref;
+    typedef _Const_mem_fun1_ref<_Result,_Tp,_Arg> _Ref_const;
+  };
+};
+
+template<class _Arg, class _Result>
+class _Ptr_fun1_base : public unary_function<_Arg, _Result> {
+protected:
+  typedef _Result (*__fun_type) (_Arg);
+  explicit _Ptr_fun1_base(__fun_type __f) : _M_f(__f) {}
+
+public:
+  _Result operator()(_Arg __x) const { return _M_f(__x); }
+
+private:
+  __fun_type _M_f;
+};
+
+template <class _Arg1, class _Arg2, class _Result>
+class _Ptr_fun2_base : public binary_function<_Arg1,_Arg2,_Result> {
+protected:
+  typedef _Result (*__fun_type) (_Arg1, _Arg2);
+  explicit _Ptr_fun2_base(__fun_type __f) : _M_f(__f) {}
+
+public:
+  _Result operator()(_Arg1 __x, _Arg2 __y) const { return _M_f(__x, __y); }
+
+private:
+  __fun_type _M_f;
+};
+
+template<class _Result>
+struct _Ptr_fun_traits {
+  template<class _Arg> struct _Args1 {
+    typedef _Ptr_fun1_base<_Arg,_Result> _Fun;
+  };
+
+  template<class _Arg1, class _Arg2> struct _Args2 {
+    typedef _Ptr_fun2_base<_Arg1,_Arg2,_Result> _Fun;
+  };
+};
+
+/* Specializations for void return type */
+template<class _Tp>
+class _Void_mem_fun0_ptr : public unary_function<_Tp*,void> {
+protected:
+  typedef void (_Tp::*__fun_type) ();
+  explicit _Void_mem_fun0_ptr(__fun_type __f) : _M_f(__f) {}
+
+public:
+  void operator ()(_Tp* __p) const { (__p->*_M_f)(); }
+
+private:
+  __fun_type _M_f;
+};
+
+template<class _Tp, class _Arg>
+class _Void_mem_fun1_ptr : public binary_function<_Tp*,_Arg,void> {
+protected:
+  typedef void (_Tp::*__fun_type) (_Arg);
+  explicit _Void_mem_fun1_ptr(__fun_type __f) : _M_f(__f) {}
+
+public:
+  void operator ()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
+
+private:
+  __fun_type _M_f;
+};
+
+template<class _Tp>
+class _Void_const_mem_fun0_ptr : public unary_function<const _Tp*,void> {
+protected:
+  typedef void (_Tp::*__fun_type) () const;
+  explicit _Void_const_mem_fun0_ptr(__fun_type __f) : _M_f(__f) {}
+
+public:
+  void operator ()(const _Tp* __p) const { (__p->*_M_f)(); }
+
+private:
+  __fun_type _M_f;
+};
+
+template<class _Tp, class _Arg>
+class _Void_const_mem_fun1_ptr : public binary_function<const _Tp*,_Arg,void> {
+protected:
+  typedef void (_Tp::*__fun_type) (_Arg) const;
+  explicit _Void_const_mem_fun1_ptr(__fun_type __f) : _M_f(__f) {}
+
+public:
+  void operator ()(const _Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
+
+private:
+  __fun_type _M_f;
+};
+
+template<class _Tp>
+class _Void_mem_fun0_ref : public unary_function<_Tp,void> {
+protected:
+  typedef void (_Tp::*__fun_type) ();
+  explicit _Void_mem_fun0_ref(__fun_type __f) : _M_f(__f) {}
+
+public:
+  void operator ()(_Tp& __p) const { (__p.*_M_f)(); }
+
+private:
+  __fun_type _M_f;
+};
+
+template<class _Tp, class _Arg>
+class _Void_mem_fun1_ref : public binary_function<_Tp,_Arg,void> {
+protected:
+  typedef void (_Tp::*__fun_type) (_Arg);
+  explicit _Void_mem_fun1_ref(__fun_type __f) : _M_f(__f) {}
+
+public:
+  void operator ()(_Tp& __p, _Arg __x) const { (__p.*_M_f)(__x); }
+
+private:
+  __fun_type _M_f;
+};
+
+template<class _Tp>
+class _Void_const_mem_fun0_ref : public unary_function<_Tp,void> {
+protected:
+  typedef void (_Tp::*__fun_type) () const;
+  explicit _Void_const_mem_fun0_ref(__fun_type __f) : _M_f(__f) {}
+
+public:
+  void operator ()(const _Tp& __p) const { (__p.*_M_f)(); }
+
+private:
+  __fun_type _M_f;
+};
+
+template<class _Tp, class _Arg>
+class _Void_const_mem_fun1_ref : public binary_function<_Tp,_Arg,void> {
+protected:
+  typedef void (_Tp::*__fun_type) (_Arg) const;
+  explicit _Void_const_mem_fun1_ref(__fun_type __f) : _M_f(__f) {}
+
+public:
+  void operator ()(const _Tp& __p, _Arg __x) const { (__p.*_M_f)(__x); }
+
+private:
+  __fun_type _M_f;
+};
+
+_STLP_TEMPLATE_NULL
+struct _Mem_fun_traits<void> {
+  template<class _Tp> struct _Args0 {
+    typedef _Void_mem_fun0_ptr<_Tp>             _Ptr;
+    typedef _Void_const_mem_fun0_ptr<_Tp>       _Ptr_const;
+    typedef _Void_mem_fun0_ref<_Tp>             _Ref;
+    typedef _Void_const_mem_fun0_ref<_Tp>       _Ref_const;
+  };
+
+  template<class _Tp, class _Arg> struct _Args1 {
+    typedef _Void_mem_fun1_ptr<_Tp,_Arg>        _Ptr;
+    typedef _Void_const_mem_fun1_ptr<_Tp,_Arg>  _Ptr_const;
+    typedef _Void_mem_fun1_ref<_Tp,_Arg>        _Ref;
+    typedef _Void_const_mem_fun1_ref<_Tp,_Arg>  _Ref_const;
+  };
+};
+
+template<class _Arg>
+class _Ptr_void_fun1_base : public unary_function<_Arg, void> {
+protected:
+  typedef void (*__fun_type) (_Arg);
+  explicit _Ptr_void_fun1_base(__fun_type __f) : _M_f(__f) {}
+
+public:
+  void operator()(_Arg __x) const { _M_f(__x); }
+
+private:
+  __fun_type _M_f;
+};
+
+template <class _Arg1, class _Arg2>
+class _Ptr_void_fun2_base : public binary_function<_Arg1,_Arg2,void> {
+protected:
+  typedef void (*__fun_type) (_Arg1, _Arg2);
+  explicit _Ptr_void_fun2_base(__fun_type __f) : _M_f(__f) {}
+
+public:
+  void operator()(_Arg1 __x, _Arg2 __y) const { _M_f(__x, __y); }
+
+private:
+  __fun_type _M_f;
+};
+
+_STLP_TEMPLATE_NULL
+struct _Ptr_fun_traits<void> {
+  template<class _Arg> struct _Args1 {
+    typedef _Ptr_void_fun1_base<_Arg> _Fun;
+  };
+
+  template<class _Arg1, class _Arg2> struct _Args2 {
+    typedef _Ptr_void_fun2_base<_Arg1,_Arg2> _Fun;
+  };
+};
+
+// pavel: need extra level of inheritance here since MSVC++ does not
+// accept traits-based fake partial specialization for template
+// arguments other than first
+
+template<class _Result, class _Arg>
+class _Ptr_fun1 :
+  public _Ptr_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Arg>::_Fun {
+protected:
+  typedef typename _Ptr_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Arg>::_Fun _Base;
+  explicit _Ptr_fun1(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template<class _Result, class _Arg1, class _Arg2>
+class _Ptr_fun2 :
+  public _Ptr_fun_traits<_Result>::_STLP_TEMPLATE _Args2<_Arg1,_Arg2>::_Fun {
+protected:
+  typedef typename _Ptr_fun_traits<_Result>::_STLP_TEMPLATE _Args2<_Arg1,_Arg2>::_Fun _Base;
+  explicit _Ptr_fun2(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template <class _Result, class _Tp>
+class mem_fun_t :
+  public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ptr {
+  typedef typename
+    _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ptr _Base;
+public:
+  explicit mem_fun_t(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template <class _Result, class _Tp>
+class const_mem_fun_t :
+  public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ptr_const {
+  typedef typename
+    _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ptr_const _Base;
+public:
+  explicit const_mem_fun_t(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template <class _Result, class _Tp>
+class mem_fun_ref_t :
+  public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ref {
+  typedef typename
+    _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ref _Base;
+public:
+  explicit mem_fun_ref_t(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template <class _Result, class _Tp>
+class const_mem_fun_ref_t :
+  public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ref_const {
+  typedef typename
+    _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ref_const _Base;
+public:
+  explicit const_mem_fun_ref_t(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template <class _Result, class _Tp, class _Arg>
+class mem_fun1_t :
+  public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ptr {
+  typedef typename
+    _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ptr _Base;
+public:
+  explicit mem_fun1_t(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template <class _Result, class _Tp, class _Arg>
+class const_mem_fun1_t :
+  public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ptr_const {
+  typedef typename
+    _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ptr_const _Base;
+public:
+  explicit const_mem_fun1_t(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template <class _Result, class _Tp, class _Arg>
+class mem_fun1_ref_t :
+  public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ref {
+  typedef typename
+    _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ref _Base;
+public:
+  explicit mem_fun1_ref_t(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template <class _Result, class _Tp, class _Arg>
+class const_mem_fun1_ref_t :
+  public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ref_const {
+  typedef typename
+    _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ref_const _Base;
+public:
+  explicit const_mem_fun1_ref_t(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template <class _Arg, class _Result>
+class pointer_to_unary_function :
+  public _Ptr_fun1<_Result,_Arg> {
+  typedef typename
+    _Ptr_fun1<_Result,_Arg>::__fun_type __fun_type;
+public:
+  explicit pointer_to_unary_function(__fun_type __f)
+    : _Ptr_fun1<_Result,_Arg>(__f) {}
+};
+
+template <class _Arg1, class _Arg2, class _Result>
+class pointer_to_binary_function :
+  public _Ptr_fun2<_Result,_Arg1,_Arg2> {
+  typedef typename
+    _Ptr_fun2<_Result,_Arg1,_Arg2>::__fun_type __fun_type;
+public:
+  explicit pointer_to_binary_function(__fun_type __f)
+    : _Ptr_fun2<_Result,_Arg1,_Arg2>(__f) {}
+};
+
+#else
+
+template <class _Ret, class _Tp>
+class mem_fun_t : public unary_function<_Tp*,_Ret> {
+  typedef _Ret (_Tp::*__fun_type)(void);
+public:
+  explicit mem_fun_t(__fun_type __pf) : _M_f(__pf) {}
+  _Ret operator()(_Tp* __p) const { return (__p->*_M_f)(); }
+private:
+  __fun_type _M_f;
+};
+
+template <class _Ret, class _Tp>
+class const_mem_fun_t : public unary_function<const _Tp*,_Ret> {
+  typedef _Ret (_Tp::*__fun_type)(void) const;
+public:
+  explicit const_mem_fun_t(__fun_type __pf) : _M_f(__pf) {}
+  _Ret operator()(const _Tp* __p) const { return (__p->*_M_f)(); }
+private:
+  __fun_type _M_f;
+};
+
+template <class _Ret, class _Tp>
+class mem_fun_ref_t : public unary_function<_Tp,_Ret> {
+  typedef _Ret (_Tp::*__fun_type)(void);
+public:
+  explicit mem_fun_ref_t(__fun_type __pf) : _M_f(__pf) {}
+  _Ret operator()(_Tp& __r) const { return (__r.*_M_f)(); }
+private:
+  __fun_type _M_f;
+};
+
+template <class _Ret, class _Tp>
+class const_mem_fun_ref_t : public unary_function<_Tp,_Ret> {
+  typedef _Ret (_Tp::*__fun_type)(void) const;
+public:
+  explicit const_mem_fun_ref_t(__fun_type __pf) : _M_f(__pf) {}
+  _Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); }
+private:
+  __fun_type _M_f;
+};
+
+template <class _Ret, class _Tp, class _Arg>
+class mem_fun1_t : public binary_function<_Tp*,_Arg,_Ret> {
+  typedef _Ret (_Tp::*__fun_type)(_Arg);
+public:
+  explicit mem_fun1_t(__fun_type __pf) : _M_f(__pf) {}
+  _Ret operator()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); }
+private:
+  __fun_type _M_f;
+};
+
+template <class _Ret, class _Tp, class _Arg>
+class const_mem_fun1_t : public binary_function<const _Tp*,_Arg,_Ret> {
+  typedef _Ret (_Tp::*__fun_type)(_Arg) const;
+public:
+  explicit const_mem_fun1_t(__fun_type __pf) : _M_f(__pf) {}
+  _Ret operator()(const _Tp* __p, _Arg __x) const
+    { return (__p->*_M_f)(__x); }
+private:
+  __fun_type _M_f;
+};
+
+template <class _Ret, class _Tp, class _Arg>
+class mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
+  typedef _Ret (_Tp::*__fun_type)(_Arg);
+public:
+  explicit mem_fun1_ref_t(__fun_type __pf) : _M_f(__pf) {}
+  _Ret operator()(_Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
+private:
+  __fun_type _M_f;
+};
+
+template <class _Ret, class _Tp, class _Arg>
+class const_mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
+  typedef _Ret (_Tp::*__fun_type)(_Arg) const;
+public:
+  explicit const_mem_fun1_ref_t(__fun_type __pf) : _M_f(__pf) {}
+  _Ret operator()(const _Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
+private:
+  __fun_type _M_f;
+};
+
+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 _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);
+    }
+};
+
+#  if defined (_STLP_DONT_RETURN_VOID) && !defined (_STLP_NO_CLASS_PARTIAL_SPECIALIZATION)
+//Partial specializations for the void type
+template <class _Tp>
+class mem_fun_t<void, _Tp> : public unary_function<_Tp*,void> {
+  typedef void (_Tp::*__fun_type)(void);
+public:
+  explicit mem_fun_t _STLP_PSPEC2(void,_Tp) (__fun_type __pf) : _M_f(__pf) {}
+  void operator()(_Tp* __p) const { (__p->*_M_f)(); }
+private:
+  __fun_type _M_f;
+};
+
+template <class _Tp>
+class const_mem_fun_t<void, _Tp> : public unary_function<const _Tp*,void> {
+  typedef void (_Tp::*__fun_type)(void) const;
+public:
+  explicit const_mem_fun_t _STLP_PSPEC2(void,_Tp) (__fun_type __pf) : _M_f(__pf) {}
+  void operator()(const _Tp* __p) const { (__p->*_M_f)(); }
+private:
+  __fun_type _M_f;
+};
+
+template <class _Tp>
+class mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
+  typedef void (_Tp::*__fun_type)(void);
+public:
+  explicit mem_fun_ref_t _STLP_PSPEC2(void,_Tp) (__fun_type __pf) : _M_f(__pf) {}
+  void operator()(_Tp& __r) const { (__r.*_M_f)(); }
+private:
+  __fun_type _M_f;
+};
+
+template <class _Tp>
+class const_mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
+  typedef void (_Tp::*__fun_type)(void) const;
+public:
+  explicit const_mem_fun_ref_t _STLP_PSPEC2(void,_Tp) (__fun_type __pf) : _M_f(__pf) {}
+  void operator()(const _Tp& __r) const { (__r.*_M_f)(); }
+private:
+  __fun_type _M_f;
+};
+
+template <class _Tp, class _Arg>
+class mem_fun1_t<void, _Tp, _Arg> : public binary_function<_Tp*,_Arg,void> {
+  typedef void (_Tp::*__fun_type)(_Arg);
+public:
+  explicit mem_fun1_t _STLP_PSPEC3(void,_Tp,_Arg) (__fun_type __pf) : _M_f(__pf) {}
+  void operator()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
+private:
+  __fun_type _M_f;
+};
+
+template <class _Tp, class _Arg>
+class const_mem_fun1_t<void, _Tp, _Arg>
+  : public binary_function<const _Tp*,_Arg,void> {
+  typedef void (_Tp::*__fun_type)(_Arg) const;
+public:
+  explicit const_mem_fun1_t _STLP_PSPEC3(void,_Tp,_Arg) (__fun_type __pf) : _M_f(__pf) {}
+  void operator()(const _Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
+private:
+  __fun_type _M_f;
+};
+
+template <class _Tp, class _Arg>
+class mem_fun1_ref_t<void, _Tp, _Arg>
+  : public binary_function<_Tp,_Arg,void> {
+  typedef void (_Tp::*__fun_type)(_Arg);
+public:
+  explicit mem_fun1_ref_t _STLP_PSPEC3(void,_Tp,_Arg) (__fun_type __pf) : _M_f(__pf) {}
+  void operator()(_Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
+private:
+  __fun_type _M_f;
+};
+
+template <class _Tp, class _Arg>
+class const_mem_fun1_ref_t<void, _Tp, _Arg>
+  : public binary_function<_Tp,_Arg,void> {
+  typedef void (_Tp::*__fun_type)(_Arg) const;
+public:
+  explicit const_mem_fun1_ref_t _STLP_PSPEC3(void,_Tp,_Arg) (__fun_type __pf) : _M_f(__pf) {}
+  void operator()(const _Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
+private:
+  __fun_type _M_f;
+};
+
+template <class _Arg>
+class pointer_to_unary_function<_Arg, void> : public unary_function<_Arg, void> {
+  typedef void (*__fun_type)(_Arg);
+  __fun_type _M_ptr;
+public:
+  pointer_to_unary_function() {}
+  explicit pointer_to_unary_function(__fun_type __x) : _M_ptr(__x) {}
+  void operator()(_Arg __x) const { _M_ptr(__x); }
+};
+
+template <class _Arg1, class _Arg2>
+class pointer_to_binary_function<_Arg1, _Arg2, void> : public binary_function<_Arg1,_Arg2,void> {
+  typedef void (*__fun_type)(_Arg1, _Arg2);
+  __fun_type _M_ptr;
+public:
+  pointer_to_binary_function() {}
+  explicit pointer_to_binary_function(__fun_type __x) : _M_ptr(__x) {}
+  void operator()(_Arg1 __x, _Arg2 __y) const { _M_ptr(__x, __y); }
+};
+
+#  endif
+
+#endif
+
+#if !defined (_STLP_MEMBER_POINTER_PARAM_BUG)
+// 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 _Result, class _Tp>
+inline mem_fun_t<_Result,_Tp>
+mem_fun(_Result (_Tp::*__f)()) { return mem_fun_t<_Result,_Tp>(__f); }
+
+template <class _Result, class _Tp>
+inline const_mem_fun_t<_Result,_Tp>
+mem_fun(_Result (_Tp::*__f)() const)  { return const_mem_fun_t<_Result,_Tp>(__f); }
+
+template <class _Result, class _Tp>
+inline mem_fun_ref_t<_Result,_Tp>
+mem_fun_ref(_Result (_Tp::*__f)())  { return mem_fun_ref_t<_Result,_Tp>(__f); }
+
+template <class _Result, class _Tp>
+inline const_mem_fun_ref_t<_Result,_Tp>
+mem_fun_ref(_Result (_Tp::*__f)() const)  { return const_mem_fun_ref_t<_Result,_Tp>(__f); }
+
+template <class _Result, class _Tp, class _Arg>
+inline mem_fun1_t<_Result,_Tp,_Arg>
+mem_fun(_Result (_Tp::*__f)(_Arg)) { return mem_fun1_t<_Result,_Tp,_Arg>(__f); }
+
+template <class _Result, class _Tp, class _Arg>
+inline const_mem_fun1_t<_Result,_Tp,_Arg>
+mem_fun(_Result (_Tp::*__f)(_Arg) const) { return const_mem_fun1_t<_Result,_Tp,_Arg>(__f); }
+
+template <class _Result, class _Tp, class _Arg>
+inline mem_fun1_ref_t<_Result,_Tp,_Arg>
+mem_fun_ref(_Result (_Tp::*__f)(_Arg)) { return mem_fun1_ref_t<_Result,_Tp,_Arg>(__f); }
+
+template <class _Result, class _Tp, class _Arg>
+inline const_mem_fun1_ref_t<_Result,_Tp,_Arg>
+mem_fun_ref(_Result (_Tp::*__f)(_Arg) const) { return const_mem_fun1_ref_t<_Result,_Tp,_Arg>(__f); }
+
+#  if !(defined (_STLP_NO_EXTENSIONS) || defined (_STLP_NO_ANACHRONISMS))
+//  mem_fun1 and mem_fun1_ref are no longer part of the C++ standard,
+//  but they are provided for backward compatibility.
+template <class _Result, class _Tp, class _Arg>
+inline mem_fun1_t<_Result,_Tp,_Arg>
+mem_fun1(_Result (_Tp::*__f)(_Arg)) { return mem_fun1_t<_Result,_Tp,_Arg>(__f); }
+
+template <class _Result, class _Tp, class _Arg>
+inline const_mem_fun1_t<_Result,_Tp,_Arg>
+mem_fun1(_Result (_Tp::*__f)(_Arg) const) { return const_mem_fun1_t<_Result,_Tp,_Arg>(__f); }
+
+template <class _Result, class _Tp, class _Arg>
+inline mem_fun1_ref_t<_Result,_Tp,_Arg>
+mem_fun1_ref(_Result (_Tp::*__f)(_Arg)) { return mem_fun1_ref_t<_Result,_Tp,_Arg>(__f); }
+
+template <class _Result, class _Tp, class _Arg>
+inline const_mem_fun1_ref_t<_Result,_Tp,_Arg>
+mem_fun1_ref(_Result (_Tp::*__f)(_Arg) const) { return const_mem_fun1_ref_t<_Result,_Tp,_Arg>(__f); }
+
+#  endif
+
+#endif
+
+template <class _Arg, class _Result>
+inline pointer_to_unary_function<_Arg, _Result>
+ptr_fun(_Result (*__f)(_Arg))
+{ return pointer_to_unary_function<_Arg, _Result>(__f); }
+
+template <class _Arg1, class _Arg2, class _Result>
+inline pointer_to_binary_function<_Arg1,_Arg2,_Result>
+ptr_fun(_Result (*__f)(_Arg1, _Arg2))
+{ return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f); }
+
+_STLP_END_NAMESPACE
diff --git a/stlport/stlport/stl/_hash_fun.h b/stlport/stlport/stl/_hash_fun.h
new file mode 100644
index 0000000..6197d7b
--- /dev/null
+++ b/stlport/stlport/stl/_hash_fun.h
@@ -0,0 +1,146 @@
+/*
+ * 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 _STLP_HASH_FUN_H
+#define _STLP_HASH_FUN_H
+
+#ifndef _STLP_INTERNAL_CSTDDEF
+#  include <stl/_cstddef.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _Key> struct hash { };
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+inline size_t __stl_hash_string(const char* __s) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  unsigned long __h = 0;
+  for ( ; *__s; ++__s)
+    __h = 5*__h + *__s;
+
+  return size_t(__h);
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_TEMPLATE_NULL
+struct hash<char*> {
+  size_t operator()(const char* __s) const {
+    _STLP_FIX_LITERAL_BUG(__s)
+    return _STLP_PRIV __stl_hash_string(__s);
+  }
+};
+
+_STLP_TEMPLATE_NULL
+struct hash<const char*> {
+  size_t operator()(const char* __s) const {
+    _STLP_FIX_LITERAL_BUG(__s)
+    return _STLP_PRIV __stl_hash_string(__s);
+  }
+};
+
+_STLP_TEMPLATE_NULL struct hash<char> {
+  size_t operator()(char __x) const { return __x; }
+};
+_STLP_TEMPLATE_NULL struct hash<unsigned char> {
+  size_t operator()(unsigned char __x) const { return __x; }
+};
+#if !defined (_STLP_NO_SIGNED_BUILTINS)
+_STLP_TEMPLATE_NULL struct hash<signed char> {
+  size_t operator()(unsigned char __x) const { return __x; }
+};
+#endif
+_STLP_TEMPLATE_NULL struct hash<short> {
+  size_t operator()(short __x) const { return __x; }
+};
+_STLP_TEMPLATE_NULL struct hash<unsigned short> {
+  size_t operator()(unsigned short __x) const { return __x; }
+};
+_STLP_TEMPLATE_NULL struct hash<int> {
+  size_t operator()(int __x) const { return __x; }
+};
+
+#if !defined (_STLP_MSVC) || (_STLP_MSVC < 1300) || defined (_WIN64)
+_STLP_TEMPLATE_NULL struct hash<unsigned int> {
+  size_t operator()(unsigned int __x) const { return __x; }
+};
+#else
+/* MSVC .Net since 2002 has a 64 bits portability warning feature. typedef
+ * like size_t are tagged as potential 64 bits variables making them different from
+ * unsigned int. To avoid the warning when a hash container is instanciated with
+ * the size_t key we prefer to grant the size_t specialization rather than the
+ * unsigned int one.
+ */
+_STLP_TEMPLATE_NULL struct hash<size_t> {
+  size_t operator()(size_t __x) const { return __x; }
+};
+#endif
+
+_STLP_TEMPLATE_NULL struct hash<long> {
+  size_t operator()(long __x) const { return __x; }
+};
+_STLP_TEMPLATE_NULL struct hash<unsigned long> {
+  size_t operator()(unsigned long __x) const { return __x; }
+};
+
+#if defined (_STLP_LONG_LONG)
+_STLP_TEMPLATE_NULL struct hash<_STLP_LONG_LONG> {
+  size_t operator()(_STLP_LONG_LONG x) const { return (size_t)x; }
+};
+_STLP_TEMPLATE_NULL struct hash<unsigned _STLP_LONG_LONG> {
+  size_t operator()(unsigned _STLP_LONG_LONG x) const { return (size_t)x; }
+};
+#endif
+
+_STLP_TEMPLATE_NULL
+struct hash<void *>
+{
+    union __vp {
+        size_t s;
+        void  *p;
+    };
+
+    size_t operator()(void *__x) const
+      {
+        __vp vp;
+        vp.p = __x;
+        return vp.s;
+      }
+};
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_HASH_FUN_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_hash_map.h b/stlport/stlport/stl/_hash_map.h
new file mode 100644
index 0000000..cd46603
--- /dev/null
+++ b/stlport/stlport/stl/_hash_map.h
@@ -0,0 +1,500 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_HASH_MAP_H
+#define _STLP_INTERNAL_HASH_MAP_H
+
+#ifndef _STLP_INTERNAL_HASHTABLE_H
+#  include <stl/_hashtable.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//Specific iterator traits creation
+_STLP_CREATE_HASH_ITERATOR_TRAITS(HashMapTraitsT, traits)
+
+template <class _Key, class _Tp, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Key>),
+          _STLP_DFL_TMPL_PARAM(_EqualKey,equal_to<_Key>),
+          _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_STLP_CONST _Key, _Tp) >
+class hash_map
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+               : public __stlport_class<hash_map<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> >
+#endif
+{
+private:
+  typedef hash_map<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> _Self;
+public:
+  typedef _Key key_type;
+  typedef _Tp data_type;
+  typedef _Tp mapped_type;
+  typedef pair<_STLP_CONST key_type, data_type> value_type;
+private:
+  //Specific iterator traits creation
+  typedef _STLP_PRIV _HashMapTraitsT<value_type> _HashMapTraits;
+
+public:
+  typedef hashtable<value_type, key_type, _HashFcn, _HashMapTraits,
+                    _STLP_SELECT1ST(value_type, _Key), _EqualKey, _Alloc > _Ht;
+
+  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(); }
+
+private:
+  _Ht _M_ht;
+  _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+public:
+  hash_map() : _M_ht(0, 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) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+  hash_map(__move_source<_Self> src)
+    : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {
+  }
+#endif
+
+#ifdef _STLP_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  hash_map(_InputIterator __f, _InputIterator __l)
+    : _M_ht(0, 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); }
+# ifdef _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS
+  template <class _InputIterator>
+  hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
+           const hasher& __hf, const key_equal& __eql)
+    : _M_ht(__n, __hf, __eql, allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+# endif
+  template <class _InputIterator>
+  hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
+           const hasher& __hf, const key_equal& __eql,
+           const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+    : _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(0, 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(0, 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 /*_STLP_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(_Self& __hs) { _M_ht.swap(__hs._M_ht); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+  void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+  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 _STLP_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 /*_STLP_MEMBER_TEMPLATES */
+  pair<iterator,bool> insert_noresize(const value_type& __obj)
+  { return _M_ht.insert_unique_noresize(__obj); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  iterator find(const _KT& __key) { return _M_ht.find(__key); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  _Tp& operator[](const _KT& __key) {
+    iterator __it = _M_ht.find(__key);
+    return (__it == _M_ht.end() ?
+      _M_ht._M_insert(value_type(__key, _STLP_DEFAULT_CONSTRUCTED(_Tp))).second :
+      (*__it).second );
+  }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  size_type count(const _KT& __key) const { return _M_ht.count(__key); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  pair<iterator, iterator> equal_range(const _KT& __key)
+  { return _M_ht.equal_range(__key); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  pair<const_iterator, const_iterator> equal_range(const _KT& __key) const
+  { return _M_ht.equal_range(__key); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  size_type erase(const _KT& __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); }
+};
+
+//Specific iterator traits creation
+_STLP_CREATE_HASH_ITERATOR_TRAITS(HashMultimapTraitsT, traits)
+
+template <class _Key, class _Tp, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Key>),
+          _STLP_DFL_TMPL_PARAM(_EqualKey,equal_to<_Key>),
+          _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_STLP_CONST _Key, _Tp) >
+class hash_multimap
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+                    : public __stlport_class<hash_multimap<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> >
+#endif
+{
+private:
+  typedef hash_multimap<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> _Self;
+public:
+  typedef _Key key_type;
+  typedef _Tp data_type;
+  typedef _Tp mapped_type;
+  typedef pair<_STLP_CONST key_type, data_type> value_type;
+private:
+  //Specific iterator traits creation
+  typedef _STLP_PRIV _HashMultimapTraitsT<value_type> _HashMultimapTraits;
+
+public:
+  typedef hashtable<value_type, key_type, _HashFcn, _HashMultimapTraits,
+                    _STLP_SELECT1ST(value_type,  _Key), _EqualKey, _Alloc > _Ht;
+
+  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(); }
+
+private:
+  _Ht _M_ht;
+  _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+public:
+  hash_multimap() : _M_ht(0, 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) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+  hash_multimap(__move_source<_Self> src)
+    : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {
+  }
+#endif
+
+#ifdef _STLP_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  hash_multimap(_InputIterator __f, _InputIterator __l)
+    : _M_ht(0, 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); }
+#  ifdef _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS
+  template <class _InputIterator>
+  hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
+                const hasher& __hf, const key_equal& __eql)
+    : _M_ht(__n, __hf, __eql, allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+#  endif
+  template <class _InputIterator>
+  hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
+                const hasher& __hf, const key_equal& __eql,
+                const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+    : _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(0, 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(0, 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 /*_STLP_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(_Self& __hs) { _M_ht.swap(__hs._M_ht); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+  void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+  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 _STLP_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 /*_STLP_MEMBER_TEMPLATES */
+  iterator insert_noresize(const value_type& __obj)
+    { return _M_ht.insert_equal_noresize(__obj); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  iterator find(const _KT& __key) { return _M_ht.find(__key); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  size_type count(const _KT& __key) const { return _M_ht.count(__key); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  pair<iterator, iterator>
+  equal_range(const _KT& __key) { return _M_ht.equal_range(__key); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  pair<const_iterator, const_iterator>
+  equal_range(const _KT& __key) const { return _M_ht.equal_range(__key); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  size_type erase(const _KT& __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); }
+};
+
+#define _STLP_TEMPLATE_HEADER template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
+#define _STLP_TEMPLATE_CONTAINER hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>
+#include <stl/_relops_hash_cont.h>
+#undef _STLP_TEMPLATE_CONTAINER
+#define _STLP_TEMPLATE_CONTAINER hash_multimap<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>
+#include <stl/_relops_hash_cont.h>
+#undef _STLP_TEMPLATE_CONTAINER
+#undef _STLP_TEMPLATE_HEADER
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+#  if !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Key, class _Tp, class _HashFn,  class _EqKey, class _Alloc>
+struct __move_traits<hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> > :
+  _STLP_PRIV __move_traits_help<typename hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>::_Ht>
+{};
+
+template <class _Key, class _Tp, class _HashFn,  class _EqKey, class _Alloc>
+struct __move_traits<hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> > :
+  _STLP_PRIV __move_traits_help<typename hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc>::_Ht>
+{};
+#  endif
+
+// Specialization of insert_iterator so that it will work for hash_map
+// and hash_multimap.
+template <class _Key, class _Tp, class _HashFn,  class _EqKey, class _Alloc>
+class insert_iterator<hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
+protected:
+  typedef hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> _Container;
+  _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;
+
+  insert_iterator(_Container& __x) : container(&__x) {}
+  insert_iterator(_Container& __x, typename _Container::iterator)
+    : container(&__x) {}
+  insert_iterator<_Container>&
+  operator=(const typename _Container::value_type& __val) {
+    container->insert(__val);
+    return *this;
+  }
+  insert_iterator<_Container>& operator*() { return *this; }
+  insert_iterator<_Container>& operator++() { return *this; }
+  insert_iterator<_Container>& operator++(int) { return *this; }
+};
+
+template <class _Key, class _Tp, class _HashFn,  class _EqKey, class _Alloc>
+class insert_iterator<hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
+protected:
+  typedef hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> _Container;
+  _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) : container(&__x) {}
+  insert_iterator(_Container& __x, typename _Container::iterator)
+    : container(&__x) {}
+  insert_iterator<_Container>&
+  operator=(const typename _Container::value_type& __val) {
+    container->insert(__val);
+    return *this;
+  }
+  insert_iterator<_Container>& operator*() { return *this; }
+  insert_iterator<_Container>& operator++() { return *this; }
+  insert_iterator<_Container>& operator++(int) { return *this; }
+};
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_HASH_MAP_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_hash_set.h b/stlport/stlport/stl/_hash_set.h
new file mode 100644
index 0000000..29b168b
--- /dev/null
+++ b/stlport/stlport/stl/_hash_set.h
@@ -0,0 +1,495 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_HASH_SET_H
+#define _STLP_INTERNAL_HASH_SET_H
+
+#ifndef _STLP_INTERNAL_HASHTABLE_H
+#  include <stl/_hashtable.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//Specific iterator traits creation
+_STLP_CREATE_HASH_ITERATOR_TRAITS(HashSetTraitsT, Const_traits)
+
+template <class _Value, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Value>),
+          _STLP_DFL_TMPL_PARAM(_EqualKey, equal_to<_Value>),
+          _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Value>) >
+class hash_set
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+               : public __stlport_class<hash_set<_Value, _HashFcn, _EqualKey, _Alloc> >
+#endif
+{
+  typedef hash_set<_Value, _HashFcn, _EqualKey, _Alloc> _Self;
+  //Specific iterator traits creation
+  typedef _STLP_PRIV _HashSetTraitsT<_Value> _HashSetTraits;
+public:
+  typedef hashtable<_Value, _Value, _HashFcn,
+                    _HashSetTraits, _STLP_PRIV _Identity<_Value>, _EqualKey, _Alloc> _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::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(); }
+
+private:
+  _Ht _M_ht;
+  _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+public:
+  hash_set()
+    : _M_ht(0, 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()) {}
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
+           const allocator_type& __a = allocator_type())
+#else
+  hash_set(size_type __n, const hasher& __hf, const key_equal& __eql)
+    : _M_ht(__n, __hf, __eql, allocator_type()) {}
+  hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
+           const allocator_type& __a)
+#endif
+    : _M_ht(__n, __hf, __eql, __a) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+  hash_set(__move_source<_Self> src)
+    : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {}
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _InputIterator>
+  hash_set(_InputIterator __f, _InputIterator __l)
+    : _M_ht(0, 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 _STLP_ALLOCATOR_TYPE_DFL)
+    : _M_ht(__n, __hf, __eql, __a)
+    { _M_ht.insert_unique(__f, __l); }
+#  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+  template <class _InputIterator>
+  hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
+           const hasher& __hf, const key_equal& __eql)
+    : _M_ht(__n, __hf, __eql, allocator_type())
+    { _M_ht.insert_unique(__f, __l); }
+#  endif
+#else
+  hash_set(const value_type* __f, const value_type* __l)
+    : _M_ht(0, 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(0, 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 /*_STLP_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(_Self& __hs) { _M_ht.swap(__hs._M_ht); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+  void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+  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); }
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _InputIterator>
+  void insert(_InputIterator __f, _InputIterator __l)
+#else
+  void insert(const_iterator __f, const_iterator __l)
+  {_M_ht.insert_unique(__f, __l); }
+  void insert(const value_type* __f, const value_type* __l)
+#endif
+  { _M_ht.insert_unique(__f,__l); }
+
+  pair<iterator, bool> insert_noresize(const value_type& __obj)
+  { return _M_ht.insert_unique_noresize(__obj); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  iterator find(const _KT& __key) { return _M_ht.find(__key); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  size_type count(const _KT& __key) const { return _M_ht.count(__key); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  pair<iterator, iterator> equal_range(const _KT& __key)
+  { return _M_ht.equal_range(__key); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  pair<const_iterator, const_iterator> equal_range(const _KT& __key) const
+  { return _M_ht.equal_range(__key); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  size_type erase(const _KT& __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); }
+};
+
+//Specific iterator traits creation
+_STLP_CREATE_HASH_ITERATOR_TRAITS(HashMultisetTraitsT, Const_traits)
+
+template <class _Value, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Value>),
+          _STLP_DFL_TMPL_PARAM(_EqualKey, equal_to<_Value>),
+          _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Value>) >
+class hash_multiset
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+                    : public __stlport_class<hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> >
+#endif
+{
+  typedef hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> _Self;
+  //Specific iterator traits creation
+  typedef _STLP_PRIV _HashMultisetTraitsT<_Value> _HashMultisetTraits;
+public:
+  typedef hashtable<_Value, _Value, _HashFcn,
+                    _HashMultisetTraits, _STLP_PRIV _Identity<_Value>, _EqualKey, _Alloc> _Ht;
+
+  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::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(); }
+
+private:
+  _Ht _M_ht;
+  _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+public:
+  hash_multiset()
+    : _M_ht(0, 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)
+    : _M_ht(__n, __hf, __eql, allocator_type()) {}
+  hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql,
+                const allocator_type& __a)
+    : _M_ht(__n, __hf, __eql, __a) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+  hash_multiset(__move_source<_Self> src)
+    : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {}
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _InputIterator>
+  hash_multiset(_InputIterator __f, _InputIterator __l)
+    : _M_ht(0, 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 _STLP_ALLOCATOR_TYPE_DFL)
+    : _M_ht(__n, __hf, __eql, __a)
+    { _M_ht.insert_equal(__f, __l); }
+#  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+  template <class _InputIterator>
+  hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
+                const hasher& __hf, const key_equal& __eql)
+    : _M_ht(__n, __hf, __eql, allocator_type())
+    { _M_ht.insert_equal(__f, __l); }
+#  endif
+#else
+  hash_multiset(const value_type* __f, const value_type* __l)
+    : _M_ht(0, 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(0, 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 /*_STLP_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(_Self& hs) { _M_ht.swap(hs._M_ht); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+  void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+  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); }
+#if defined (_STLP_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 /*_STLP_MEMBER_TEMPLATES */
+  iterator insert_noresize(const value_type& __obj)
+  { return _M_ht.insert_equal_noresize(__obj); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  iterator find(const _KT& __key) { return _M_ht.find(__key); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  size_type count(const _KT& __key) const { return _M_ht.count(__key); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  pair<iterator, iterator> equal_range(const _KT& __key)
+  { return _M_ht.equal_range(__key); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  pair<const_iterator, const_iterator> equal_range(const _KT& __key) const
+  { return _M_ht.equal_range(__key); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  size_type erase(const _KT& __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); }
+};
+
+#define _STLP_TEMPLATE_HEADER template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+#define _STLP_TEMPLATE_CONTAINER hash_set<_Value,_HashFcn,_EqualKey,_Alloc>
+
+#include <stl/_relops_hash_cont.h>
+
+#undef _STLP_TEMPLATE_CONTAINER
+#define _STLP_TEMPLATE_CONTAINER hash_multiset<_Value,_HashFcn,_EqualKey,_Alloc>
+#include <stl/_relops_hash_cont.h>
+
+#undef _STLP_TEMPLATE_CONTAINER
+#undef _STLP_TEMPLATE_HEADER
+
+// Specialization of insert_iterator so that it will work for hash_set
+// and hash_multiset.
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+#  if !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+struct __move_traits<hash_set<_Value, _HashFcn, _EqualKey, _Alloc> > :
+  _STLP_PRIV __move_traits_aux<typename hash_set<_Value, _HashFcn, _EqualKey, _Alloc>::_Ht>
+{};
+
+template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+struct __move_traits<hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> > :
+  _STLP_PRIV __move_traits_aux<typename hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>::_Ht>
+{};
+#  endif
+
+template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+class insert_iterator<hash_set<_Value, _HashFcn, _EqualKey, _Alloc> > {
+protected:
+  typedef hash_set<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
+  _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;
+
+  insert_iterator(_Container& __x) : container(&__x) {}
+  insert_iterator(_Container& __x, typename _Container::iterator)
+    : container(&__x) {}
+  insert_iterator<_Container>&
+  operator=(const typename _Container::value_type& __val) {
+    container->insert(__val);
+    return *this;
+  }
+  insert_iterator<_Container>& operator*() { return *this; }
+  insert_iterator<_Container>& operator++() { return *this; }
+  insert_iterator<_Container>& operator++(int) { return *this; }
+};
+
+template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+class insert_iterator<hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> > {
+protected:
+  typedef hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
+  _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) : container(&__x) {}
+  insert_iterator(_Container& __x, typename _Container::iterator)
+    : container(&__x) {}
+  insert_iterator<_Container>&
+  operator=(const typename _Container::value_type& __val) {
+    container->insert(__val);
+    return *this;
+  }
+  insert_iterator<_Container>& operator*() { return *this; }
+  insert_iterator<_Container>& operator++() { return *this; }
+  insert_iterator<_Container>& operator++(int) { return *this; }
+};
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_HASH_SET_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_hashtable.c b/stlport/stlport/stl/_hashtable.c
new file mode 100644
index 0000000..ddc21bb
--- /dev/null
+++ b/stlport/stlport/stl/_hashtable.c
@@ -0,0 +1,553 @@
+/*
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_HASHTABLE_C
+#define _STLP_HASHTABLE_C
+
+#ifndef _STLP_INTERNAL_HASHTABLE_H
+#  include <stl/_hashtable.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+#  define __PRIME_LIST_BODY { \
+  7ul,          23ul, \
+  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  \
+}
+
+template <class _Dummy>
+const size_t* _STLP_CALL
+_Stl_prime<_Dummy>::_S_primes(size_t &__size) {
+  static const size_t _list[] = __PRIME_LIST_BODY;
+#  ifndef __MWERKS__
+  __size =  sizeof(_list) / sizeof(_list[0]);
+#  else
+  __size =  30;
+#  endif
+  return _list;
+}
+
+template <class _Dummy>
+size_t _STLP_CALL
+_Stl_prime<_Dummy>::_S_max_nb_buckets() {
+  size_t __size;
+  const size_t* __first = _S_primes(__size);
+  return *(__first + __size - 1);
+}
+
+template <class _Dummy>
+size_t _STLP_CALL
+_Stl_prime<_Dummy>::_S_next_size(size_t __n) {
+  size_t __size;
+  const size_t* __first = _S_primes(__size);
+  const size_t* __last =  __first + __size;
+  const size_t* pos = __lower_bound(__first, __last, __n, 
+                                    __less((size_t*)0), __less((size_t*)0), (ptrdiff_t*)0);
+  return (pos == __last ? *(__last - 1) : *pos);
+}
+
+template <class _Dummy>
+void _STLP_CALL
+_Stl_prime<_Dummy>::_S_prev_sizes(size_t __n, size_t const*&__begin, size_t const*&__pos) {
+  size_t __size;
+  __begin = _S_primes(__size);
+  const size_t* __last =  __begin + __size;
+  __pos = __lower_bound(__begin, __last, __n, 
+                        __less((size_t*)0), __less((size_t*)0), (ptrdiff_t*)0);
+
+  if (__pos== __last)
+    --__pos;
+  else if (*__pos == __n) {
+    if (__pos != __begin)
+      --__pos;
+  }
+}
+
+#  undef __PRIME_LIST_BODY
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#endif
+
+#if defined (_STLP_DEBUG)
+#  define hashtable _STLP_NON_DBG_NAME(hashtable)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+// fbp: these defines are for outline methods definitions.
+// needed to definitions to be portable. Should not be used in method bodies.
+
+#if defined ( _STLP_NESTED_TYPE_PARAM_BUG )
+#  define __size_type__       size_t
+#  define size_type           size_t
+#  define value_type          _Val
+#  define key_type            _Key
+#  define __reference__       _Val&
+
+#  define __iterator__        _Ht_iterator<_Val, _STLP_HEADER_TYPENAME _Traits::_NonConstTraits, \
+                                           _Key, _HF, _ExK, _EqK, _All>
+#  define __const_iterator__  _Ht_iterator<_Val, _STLP_HEADER_TYPENAME _Traits::_ConstTraits, \
+                                           _Key, _HF, _ExK, _EqK, _All>
+#else
+#  define __size_type__       _STLP_TYPENAME_ON_RETURN_TYPE hashtable<_Val, _Key, _HF, _Traits, _ExK, _EqK, _All>::size_type
+#  define __reference__       _STLP_TYPENAME_ON_RETURN_TYPE  hashtable<_Val, _Key, _HF, _Traits, _ExK, _EqK, _All>::reference
+#  define __iterator__        _STLP_TYPENAME_ON_RETURN_TYPE hashtable<_Val, _Key, _HF, _Traits, _ExK, _EqK, _All>::iterator
+#  define __const_iterator__  _STLP_TYPENAME_ON_RETURN_TYPE hashtable<_Val, _Key, _HF, _Traits, _ExK, _EqK, _All>::const_iterator
+#endif
+
+/*
+ * This method is too difficult to implement for hashtable that do not
+ * require a sorted operation on the stored type.
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+bool hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>::_M_equal(
+              const hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>& __ht1,
+              const hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>& __ht2) {
+  return __ht1._M_buckets == __ht2._M_buckets &&
+         __ht1._M_elems == __ht2._M_elems;
+}
+*/
+
+/* Returns the iterator before the first iterator of the bucket __n and set
+ * __n to the first previous bucket having the same first iterator as bucket
+ * __n.
+ */
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+__iterator__
+hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+  ::_M_before_begin(size_type &__n) const {
+  return _S_before_begin(_M_elems, _M_buckets, __n);
+}
+
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+__iterator__
+hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+  ::_S_before_begin(const _ElemsCont& __elems, const _BucketVector& __buckets,
+                    size_type &__n) {
+  _ElemsCont &__mutable_elems = __CONST_CAST(_ElemsCont&, __elems);
+  typename _BucketVector::const_iterator __bpos(__buckets.begin() + __n);
+
+  _ElemsIte __pos(*__bpos);
+  if (__pos == __mutable_elems.begin()) {
+    __n = 0;
+    return __mutable_elems.before_begin();
+  }
+
+  typename _BucketVector::const_iterator __bcur(__bpos);
+  _BucketType *__pos_node = __pos._M_node;
+  for (--__bcur; __pos_node == *__bcur; --__bcur) ;
+
+  __n = __bcur - __buckets.begin() + 1;
+  _ElemsIte __cur(*__bcur);
+  _ElemsIte __prev = __cur++;
+  for (; __cur != __pos; ++__prev, ++__cur) ;
+  return __prev;
+}
+
+
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+__iterator__
+hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+  ::_M_insert_noresize(size_type __n, const value_type& __obj) {
+  //We always insert this element as 1st in the bucket to not break
+  //the elements order as equal elements must be kept next to each other.
+  size_type __prev = __n;
+  _ElemsIte __pos = _M_before_begin(__prev)._M_ite;
+
+  fill(_M_buckets.begin() + __prev, _M_buckets.begin() + __n + 1,
+       _M_elems.insert_after(__pos, __obj)._M_node);
+  ++_M_num_elements;
+  return iterator(_ElemsIte(_M_buckets[__n]));
+}
+
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+pair<__iterator__, bool>
+hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+  ::insert_unique_noresize(const value_type& __obj) {
+  const size_type __n = _M_bkt_num(__obj);
+  _ElemsIte __cur(_M_buckets[__n]);
+  _ElemsIte __last(_M_buckets[__n + 1]);
+
+  if (__cur != __last) {
+    for (; __cur != __last; ++__cur) {
+      if (_M_equals(_M_get_key(*__cur), _M_get_key(__obj))) {
+        //We check that equivalent keys have equals hash code as otherwise, on resize,
+        //equivalent value might not be in the same bucket
+        _STLP_ASSERT(_M_hash(_M_get_key(*__cur)) == _M_hash(_M_get_key(__obj)))
+        return pair<iterator, bool>(iterator(__cur), false);
+      }
+    }
+    /* Here we do not rely on the _M_insert_noresize method as we know
+     * that we cannot break element orders, elements are unique, and
+     * insertion after the first bucket element is faster than what is
+     * done in _M_insert_noresize.
+     */
+    __cur = _M_elems.insert_after(_ElemsIte(_M_buckets[__n]), __obj);
+    ++_M_num_elements;
+    return pair<iterator, bool>(iterator(__cur), true);
+  }
+
+  return pair<iterator, bool>(_M_insert_noresize(__n, __obj), true);
+}
+
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+__iterator__
+hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+  ::insert_equal_noresize(const value_type& __obj) {
+  const size_type __n = _M_bkt_num(__obj);
+  {
+    _ElemsIte __cur(_M_buckets[__n]);
+    _ElemsIte __last(_M_buckets[__n + 1]);
+
+    for (; __cur != __last; ++__cur) {
+      if (_M_equals(_M_get_key(*__cur), _M_get_key(__obj))) {
+        //We check that equivalent keys have equals hash code as otherwise, on resize,
+        //equivalent value might not be in the same bucket
+        _STLP_ASSERT(_M_hash(_M_get_key(*__cur)) == _M_hash(_M_get_key(__obj)))
+        ++_M_num_elements;
+        return _M_elems.insert_after(__cur, __obj);
+      }
+    }
+  }
+
+  return _M_insert_noresize(__n, __obj);
+}
+
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+__reference__
+hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+  ::_M_insert(const value_type& __obj) {
+  _M_enlarge(_M_num_elements + 1);
+  return *insert_unique_noresize(__obj).first;
+}
+
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+__size_type__
+hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+  ::erase(const key_type& __key) {
+  const size_type __n = _M_bkt_num_key(__key);
+
+  _ElemsIte __cur(_M_buckets[__n]);
+  _ElemsIte __last(_M_buckets[__n + 1]);
+  if (__cur == __last)
+    return 0;
+
+  size_type __erased = 0;
+  if (_M_equals(_M_get_key(*__cur), __key)) {
+    //We look for the pos before __cur:
+    size_type __prev_b = __n;
+    _ElemsIte __prev = _M_before_begin(__prev_b)._M_ite;
+    do {
+      __cur = _M_elems.erase_after(__prev);
+      ++__erased;
+    } while ((__cur != __last) && _M_equals(_M_get_key(*__cur), __key));
+    fill(_M_buckets.begin() + __prev_b, _M_buckets.begin() + __n + 1, __cur._M_node);
+  }
+  else {
+    _ElemsIte __prev = __cur++;
+    for (; __cur != __last; ++__prev, ++__cur) {
+      if (_M_equals(_M_get_key(*__cur), __key)) {
+        do {
+          __cur = _M_elems.erase_after(__prev);
+          ++__erased;
+        } while ((__cur != __last) && _M_equals(_M_get_key(*__cur), __key));
+        break;
+      }
+    }
+  }
+
+  _M_num_elements -= __erased;
+  _M_reduce();
+  return __erased;
+}
+
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+  ::erase(const_iterator __it) {
+  const size_type __n = _M_bkt_num(*__it);
+  _ElemsIte __cur(_M_buckets[__n]);
+
+  size_type __erased = 0;
+  if (__cur == __it._M_ite) {
+    size_type __prev_b = __n;
+    _ElemsIte __prev = _M_before_begin(__prev_b)._M_ite;
+    fill(_M_buckets.begin() + __prev_b, _M_buckets.begin() + __n + 1,
+         _M_elems.erase_after(__prev)._M_node);
+    ++__erased;
+  }
+  else {
+    _ElemsIte __prev = __cur++;
+    _ElemsIte __last(_M_buckets[__n + 1]);
+    for (; __cur != __last; ++__prev, ++__cur) {
+      if (__cur == __it._M_ite) {
+        _M_elems.erase_after(__prev);
+        ++__erased;
+        break;
+      }
+    }
+  }
+
+  _M_num_elements -= __erased;
+  _M_reduce();
+}
+
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+  ::erase(const_iterator __first, const_iterator __last) {
+  if (__first == __last)
+    return;
+  size_type __f_bucket = _M_bkt_num(*__first);
+  size_type __l_bucket = __last != end() ? _M_bkt_num(*__last) : (_M_buckets.size() - 1);
+
+  _ElemsIte __cur(_M_buckets[__f_bucket]);
+  _ElemsIte __prev;
+  if (__cur == __first._M_ite) {
+    __prev = _M_before_begin(__f_bucket)._M_ite;
+  }
+  else {
+    _ElemsIte __last(_M_buckets[++__f_bucket]);
+    __prev = __cur++;
+    for (; (__cur != __last) && (__cur != __first._M_ite); ++__prev, ++__cur) ;
+  }
+  size_type __erased = 0;
+  //We do not use the slist::erase_after method taking a range to count the
+  //number of erased elements:
+  while (__cur != __last._M_ite) {
+    __cur = _M_elems.erase_after(__prev);
+    ++__erased;
+  }
+  fill(_M_buckets.begin() + __f_bucket, _M_buckets.begin() + __l_bucket + 1, __cur._M_node);
+  _M_num_elements -= __erased;
+  _M_reduce();
+}
+
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+  ::rehash(size_type __num_buckets_hint) {
+  if (bucket_count() >= __num_buckets_hint) {
+    // We are trying to reduce number of buckets, we have to validate it:
+    size_type __limit_num_buckets = (size_type)((float)size() / max_load_factor());
+    if (__num_buckets_hint < __limit_num_buckets) {
+      // Targetted number of buckets __num_buckets_hint would break
+      // load_factor() <= max_load_factor() rule.
+      return;
+    }
+  }
+
+  _M_rehash(__num_buckets_hint);
+}
+
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+  ::_M_enlarge(size_type __to_size) {
+  size_type __num_buckets = bucket_count();
+  size_type __num_buckets_hint = (size_type)((float)__to_size / max_load_factor());
+  if (__num_buckets_hint <= __num_buckets) {
+    return;
+  }
+  __num_buckets = _STLP_PRIV _Stl_prime_type::_S_next_size(__num_buckets_hint);
+
+  _M_rehash(__num_buckets);
+}
+
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+  ::_M_reduce() {
+  size_type __num_buckets = bucket_count();
+  // We only try to reduce the hashtable if the theorical load factor
+  // is lower than a fraction of the max load factor:
+  // 4 factor is coming from the fact that prime number list is almost a
+  // geometrical suite with reason 2, as we try to jump 2 levels is means
+  // a 4 factor.
+  if ((float)size() / (float)__num_buckets > max_load_factor() / 4.0f)
+    return;
+
+  const size_type *__first;
+  const size_type *__prev;
+  _STLP_PRIV _Stl_prime_type::_S_prev_sizes(__num_buckets, __first, __prev);
+
+  /* We are only going to reduce number of buckets if moving to yet the previous number
+   * of buckets in the prime numbers would respect the load rule. Otherwise algorithm
+   * successively removing and adding an element would each time perform an expensive
+   * rehash operation. */
+  const size_type *__prev_prev = __prev;
+  if (__prev_prev != __first) {
+    --__prev_prev;
+    if ((float)size() / (float)*__prev_prev > max_load_factor())
+      return;
+  }
+  else {
+    if (*__prev >= __num_buckets)
+      return;
+  }
+
+  // Can we reduce further:
+  while (__prev_prev != __first) {
+    --__prev_prev;
+    if ((float)size() / (float)*__prev_prev > max_load_factor())
+      // We cannot reduce further.
+      break;
+    --__prev;
+  }
+
+  _M_rehash(*__prev);
+}
+
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+  ::_M_resize() {
+  if (load_factor() > max_load_factor()) {
+    // We have to enlarge
+    _M_enlarge(size());
+  }
+  else {
+    // We can try to reduce size:
+    _M_reduce();
+  }
+}
+
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+  ::_M_rehash(size_type __num_buckets) {
+#if defined (_STLP_DEBUG)
+  _M_check();
+#endif
+  _ElemsCont __tmp_elems(_M_elems.get_allocator());
+  _BucketVector __tmp(__num_buckets + 1, __STATIC_CAST(_BucketType*, 0), _M_buckets.get_allocator());
+  _ElemsIte __cur, __last(_M_elems.end());
+  while (!_M_elems.empty()) {
+    __cur = _M_elems.begin();
+    size_type __new_bucket = _M_bkt_num(*__cur, __num_buckets);
+    _ElemsIte __ite(__cur), __before_ite(__cur);
+    for (++__ite;
+         __ite != __last && _M_equals(_M_get_key(*__cur), _M_get_key(*__ite));
+         ++__ite, ++__before_ite) ;
+    size_type __prev_bucket = __new_bucket;
+    _ElemsIte  __prev = _S_before_begin(__tmp_elems, __tmp, __prev_bucket)._M_ite;
+    __tmp_elems.splice_after(__prev, _M_elems, _M_elems.before_begin(), __before_ite);
+    fill(__tmp.begin() + __prev_bucket, __tmp.begin() + __new_bucket + 1, __cur._M_node);
+  }
+  _M_elems.swap(__tmp_elems);
+  _M_buckets.swap(__tmp);
+}
+
+#if defined (_STLP_DEBUG)
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>::_M_check() const {
+  //We check that hash code of stored keys haven't change and also that equivalent
+  //relation hasn't been modified
+  size_t __num_buckets = bucket_count();
+  for (size_t __b = 0; __b < __num_buckets; ++__b) {
+    _ElemsIte __cur(_M_buckets[__b]), __last(_M_buckets[__b + 1]);
+    _ElemsIte __fst(__cur), __snd(__cur);
+    for (; __cur != __last; ++__cur) {
+      _STLP_ASSERT( _M_bkt_num(*__cur, __num_buckets) == __b )
+      _STLP_ASSERT( !_M_equals(_M_get_key(*__fst), _M_get_key(*__cur)) || _M_equals(_M_get_key(*__snd), _M_get_key(*__cur)) )
+      if (__fst != __snd)
+        ++__fst;
+      if (__snd != __cur)
+        ++__snd;
+    }
+  }
+}
+#endif
+
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>::clear() {
+  _M_elems.clear();
+  _M_buckets.assign(_M_buckets.size(), __STATIC_CAST(_BucketType*, 0));
+  _M_num_elements = 0;
+}
+
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+  ::_M_copy_from(const hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>& __ht) {
+  _M_elems.clear();
+  _M_elems.insert(_M_elems.end(), __ht._M_elems.begin(), __ht._M_elems.end());
+  _M_buckets.resize(__ht._M_buckets.size());
+  _ElemsConstIte __src(__ht._M_elems.begin()), __src_end(__ht._M_elems.end());
+  _ElemsIte __dst(_M_elems.begin());
+  typename _BucketVector::const_iterator __src_b(__ht._M_buckets.begin()),
+                                         __src_end_b(__ht._M_buckets.end());
+  typename _BucketVector::iterator __dst_b(_M_buckets.begin()), __dst_end_b(_M_buckets.end());
+  for (; __src != __src_end; ++__src, ++__dst) {
+    for (; __src_b != __src_end_b; ++__src_b, ++__dst_b) {
+      if (*__src_b == __src._M_node) {
+        *__dst_b = __dst._M_node;
+      }
+      else
+        break;
+    }
+  }
+  fill(__dst_b, __dst_end_b, __STATIC_CAST(_BucketType*, 0));
+  _M_num_elements = __ht._M_num_elements;
+  _M_max_load_factor = __ht._M_max_load_factor;
+}
+
+#undef __iterator__
+#undef const_iterator
+#undef __size_type__
+#undef __reference__
+#undef size_type
+#undef value_type
+#undef key_type
+#undef __stl_num_primes
+
+#if defined (_STLP_DEBUG)
+#  undef hashtable
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /*  _STLP_HASHTABLE_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_hashtable.h b/stlport/stlport/stl/_hashtable.h
new file mode 100644
index 0000000..0d2bda6
--- /dev/null
+++ b/stlport/stlport/stl/_hashtable.h
@@ -0,0 +1,658 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_HASHTABLE_H
+#define _STLP_INTERNAL_HASHTABLE_H
+
+#ifndef _STLP_INTERNAL_VECTOR_H
+#  include <stl/_vector.h>
+#endif
+
+#ifndef _STLP_INTERNAL_SLIST_H
+#  include <stl/_slist.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_H
+#  include <stl/_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+#  include <stl/_function_base.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+#  include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_HASH_FUN_H
+#  include <stl/_hash_fun.h>
+#endif
+
+/*
+ * Hashtable class, used to implement the hashed associative containers
+ * hash_set, hash_map, hash_multiset, hash_multimap,
+ * unordered_set, unordered_map, unordered_multiset, unordered_multimap.
+ */
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+//Export of the classes used to represent buckets in the hashtable implementation.
+#  if !defined (_STLP_USE_PTR_SPECIALIZATIONS)
+//If pointer specialization is enabled vector<_Slist_node_base*> will use the void*
+//storage type for which internal classes have already been exported.
+_STLP_EXPORT_TEMPLATE_CLASS allocator<_STLP_PRIV _Slist_node_base*>;
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<_Slist_node_base**, _Slist_node_base*,
+                                              allocator<_Slist_node_base*> >;
+_STLP_EXPORT_TEMPLATE_CLASS _Vector_base<_Slist_node_base*,
+                                         allocator<_Slist_node_base*> >;
+_STLP_MOVE_TO_STD_NAMESPACE
+#  endif
+
+#  if defined (_STLP_DEBUG)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#    define _STLP_NON_DBG_VECTOR _STLP_NON_DBG_NAME(vector)
+_STLP_EXPORT_TEMPLATE_CLASS __construct_checker<_STLP_NON_DBG_VECTOR<_Slist_node_base*, allocator<_Slist_node_base*> > >;
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_NON_DBG_VECTOR<_Slist_node_base*, allocator<_Slist_node_base*> >;
+#    undef _STLP_NON_DBG_VECTOR
+_STLP_MOVE_TO_STD_NAMESPACE
+#  endif
+
+_STLP_EXPORT_TEMPLATE_CLASS vector<_STLP_PRIV _Slist_node_base*,
+                                   allocator<_STLP_PRIV _Slist_node_base*> >;
+#endif
+
+#if defined (_STLP_DEBUG)
+#  define hashtable _STLP_NON_DBG_NAME(hashtable)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+// some compilers require the names of template parameters to be the same
+template <class _Val, class _Key, class _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+class hashtable;
+
+#if !defined (_STLP_DEBUG)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+template <class _BaseIte, class _Traits>
+struct _Ht_iterator {
+  typedef typename _Traits::_ConstTraits _ConstTraits;
+  typedef typename _Traits::_NonConstTraits _NonConstTraits;
+
+  typedef _Ht_iterator<_BaseIte,_Traits> _Self;
+
+  typedef typename _Traits::value_type value_type;
+  typedef typename _Traits::pointer pointer;
+  typedef typename _Traits::reference reference;
+  typedef forward_iterator_tag iterator_category;
+  typedef ptrdiff_t difference_type;
+  typedef size_t size_type;
+
+  typedef _Ht_iterator<_BaseIte, _NonConstTraits> iterator;
+  typedef _Ht_iterator<_BaseIte, _ConstTraits> const_iterator;
+
+  _Ht_iterator() {}
+  //copy constructor for iterator and constructor from iterator for const_iterator
+  _Ht_iterator(const iterator& __it) : _M_ite(__it._M_ite) {}
+  _Ht_iterator(_BaseIte __it) : _M_ite(__it) {}
+
+  reference operator*() const {
+    return *_M_ite;
+  }
+  _STLP_DEFINE_ARROW_OPERATOR
+
+  _Self& operator++() {
+    ++_M_ite;
+    return *this;
+  }
+  _Self operator++(int) {
+    _Self __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
+
+  bool operator == (const_iterator __rhs) const {
+    return _M_ite == __rhs._M_ite;
+  }
+  bool operator != (const_iterator __rhs) const {
+    return _M_ite != __rhs._M_ite;
+  }
+
+  _BaseIte _M_ite;
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+template <class _BaseIte, class _Traits>
+struct __type_traits<_STLP_PRIV _Ht_iterator<_BaseIte, _Traits> > {
+  typedef __false_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 __false_type   is_POD_type;
+};
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+#if defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)
+template <class _BaseIte, class _Traits>
+inline
+#  if defined (_STLP_NESTED_TYPE_PARAM_BUG)
+_STLP_TYPENAME_ON_RETURN_TYPE _Traits::value_type *
+#  else
+_STLP_TYPENAME_ON_RETURN_TYPE _STLP_PRIV _Ht_iterator<_BaseIte,_Traits>::value_type *
+#  endif
+value_type(const _STLP_PRIV _Ht_iterator<_BaseIte,_Traits>&) {
+  typedef _STLP_TYPENAME _STLP_PRIV _Ht_iterator<_BaseIte,_Traits>::value_type _Val;
+  return (_Val*) 0;
+}
+template <class _BaseIte, class _Traits>
+inline forward_iterator_tag iterator_category(const _STLP_PRIV _Ht_iterator<_BaseIte,_Traits>&)
+{ return forward_iterator_tag(); }
+template <class _BaseIte, class _Traits>
+inline ptrdiff_t* distance_type(const _STLP_PRIV _Ht_iterator<_BaseIte,_Traits>&)
+{ return (ptrdiff_t*) 0; }
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Dummy>
+class _Stl_prime {
+  // Returns begining of primes list and size by reference.
+  static const size_t* _S_primes(size_t&);
+public:
+  //Returns the maximum number of buckets handled by the hashtable implementation
+  static size_t _STLP_CALL _S_max_nb_buckets();
+
+  //Returns the bucket size next to a required size
+  static size_t _STLP_CALL _S_next_size(size_t);
+
+  // Returns the bucket range containing sorted list of prime numbers <= __hint.
+  static void _STLP_CALL _S_prev_sizes(size_t __hint, const size_t *&__begin, const size_t *&__end);
+};
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS _Stl_prime<bool>;
+#endif
+
+typedef _Stl_prime<bool> _Stl_prime_type;
+
+#if !defined (_STLP_DEBUG)
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+/*
+ * 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 _HF,
+          class _Traits, class _ExK, class _EqK, class _All>
+class hashtable {
+  typedef hashtable<_Val, _Key, _HF, _Traits, _ExK, _EqK, _All> _Self;
+  typedef typename _Traits::_NonConstTraits _NonConstTraits;
+  typedef typename _Traits::_ConstTraits _ConstTraits;
+  typedef typename _Traits::_NonConstLocalTraits _NonConstLocalTraits;
+  typedef typename _Traits::_ConstLocalTraits _ConstLocalTraits;
+
+public:
+  typedef _Key key_type;
+  typedef _Val value_type;
+  typedef _HF hasher;
+  typedef _EqK key_equal;
+
+  typedef size_t            size_type;
+  typedef ptrdiff_t         difference_type;
+  typedef typename _NonConstTraits::pointer pointer;
+  typedef const value_type* const_pointer;
+  typedef typename _NonConstTraits::reference reference;
+  typedef const value_type& const_reference;
+  typedef forward_iterator_tag _Iterator_category;
+
+  hasher hash_funct() const { return _M_hash; }
+  key_equal key_eq() const { return _M_equals; }
+
+private:
+  _STLP_FORCE_ALLOCATORS(_Val, _All)
+#if defined (_STLP_DEBUG)
+  typedef _STLP_PRIV _STLP_NON_DBG_NAME(slist)<value_type, _All> _ElemsCont;
+#else
+  typedef slist<value_type, _All> _ElemsCont;
+#endif
+  typedef typename _ElemsCont::iterator _ElemsIte;
+  typedef typename _ElemsCont::const_iterator _ElemsConstIte;
+  typedef _STLP_PRIV _Slist_node_base _BucketType;
+  typedef typename _Alloc_traits<_BucketType*, _All>::allocator_type _BucketAllocType;
+  /*
+   * We are going to use vector of _Slist_node_base pointers for 2 reasons:
+   *  - limit code bloat, all hashtable instanciation use the same buckets representation.
+   *  - avoid _STLP_DEBUG performance trouble: with a vector of iterator on slist the resize
+   *    method would be too slow because the slist::splice_after method become linear on
+   *    the number of iterators in the buckets rather than constant in time as the iterator
+   *    has to be move from a slist to the other.
+   */
+#if defined (_STLP_DEBUG)
+  typedef _STLP_PRIV _STLP_NON_DBG_NAME(vector)<_BucketType*, _BucketAllocType> _BucketVector;
+#else
+  typedef vector<_BucketType*, _BucketAllocType> _BucketVector;
+#endif
+
+  hasher                _M_hash;
+  key_equal             _M_equals;
+  _ElemsCont            _M_elems;
+  _BucketVector         _M_buckets;
+  size_type             _M_num_elements;
+  float                 _M_max_load_factor;
+  _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+  static const key_type& _M_get_key(const value_type& __val) {
+    _ExK k;
+    return k(__val);
+  }
+public:
+  typedef _STLP_PRIV _Ht_iterator<_ElemsIte, _NonConstTraits> iterator;
+  typedef _STLP_PRIV _Ht_iterator<_ElemsIte, _ConstTraits> const_iterator;
+  //TODO: Avoids this debug check and make the local_iterator different from
+  //iterator in debug mode too.
+#if !defined (_STLP_DEBUG)
+  typedef _STLP_PRIV _Ht_iterator<_ElemsIte, _NonConstLocalTraits> local_iterator;
+  typedef _STLP_PRIV _Ht_iterator<_ElemsIte, _ConstLocalTraits> const_local_iterator;
+#else
+  typedef iterator       local_iterator;
+  typedef const_iterator const_local_iterator;
+#endif
+
+  typedef _All allocator_type;
+  allocator_type get_allocator() const { return _M_elems.get_allocator(); }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  hashtable(size_type __n,
+            const _HF&    __hf,
+            const _EqK&   __eql,
+            const allocator_type& __a = allocator_type())
+#else
+  hashtable(size_type __n,
+            const _HF&    __hf,
+            const _EqK&   __eql)
+    : _M_hash(__hf),
+      _M_equals(__eql),
+      _M_elems(allocator_type()),
+      _M_buckets(_STLP_CONVERT_ALLOCATOR(__a, _BucketType*)),
+      _M_num_elements(0),
+      _M_max_load_factor(1.0f)
+  { _M_initialize_buckets(__n); }
+
+  hashtable(size_type __n,
+            const _HF&    __hf,
+            const _EqK&   __eql,
+            const allocator_type& __a)
+#endif
+    : _M_hash(__hf),
+      _M_equals(__eql),
+      _M_elems(__a),
+      _M_buckets(_STLP_CONVERT_ALLOCATOR(__a, _BucketType*)),
+      _M_num_elements(0),
+      _M_max_load_factor(1.0f)
+  { _M_initialize_buckets(__n); }
+
+  hashtable(const _Self& __ht)
+    : _M_hash(__ht._M_hash),
+      _M_equals(__ht._M_equals),
+      _M_elems(__ht.get_allocator()),
+      _M_buckets(_STLP_CONVERT_ALLOCATOR(__ht.get_allocator(), _BucketType*)),
+      _M_num_elements(0),
+      _M_max_load_factor(1.0f)
+  { _M_copy_from(__ht); }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+  hashtable(__move_source<_Self> src)
+    : _M_hash(_STLP_PRIV _AsMoveSource(src.get()._M_hash)),
+      _M_equals(_STLP_PRIV _AsMoveSource(src.get()._M_equals)),
+      _M_elems(__move_source<_ElemsCont>(src.get()._M_elems)),
+      _M_buckets(__move_source<_BucketVector>(src.get()._M_buckets)),
+      _M_num_elements(src.get()._M_num_elements),
+      _M_max_load_factor(src.get()._M_max_load_factor) {}
+#endif
+
+  _Self& operator= (const _Self& __ht) {
+    if (&__ht != this) {
+      clear();
+      _M_hash = __ht._M_hash;
+      _M_equals = __ht._M_equals;
+      _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(_Self& __ht) {
+    _STLP_STD::swap(_M_hash, __ht._M_hash);
+    _STLP_STD::swap(_M_equals, __ht._M_equals);
+    _M_elems.swap(__ht._M_elems);
+    _M_buckets.swap(__ht._M_buckets);
+    _STLP_STD::swap(_M_num_elements, __ht._M_num_elements);
+    _STLP_STD::swap(_M_max_load_factor, __ht._M_max_load_factor);
+  }
+
+  iterator begin() { return _M_elems.begin(); }
+  iterator end() { return _M_elems.end(); }
+  local_iterator begin(size_type __n) { return _ElemsIte(_M_buckets[__n]); }
+  local_iterator end(size_type __n) { return _ElemsIte(_M_buckets[__n + 1]); }
+
+  const_iterator begin() const { return __CONST_CAST(_ElemsCont&, _M_elems).begin(); }
+  const_iterator end() const { return __CONST_CAST(_ElemsCont&, _M_elems).end(); }
+  const_local_iterator begin(size_type __n) const { return _ElemsIte(_M_buckets[__n]); }
+  const_local_iterator end(size_type __n) const { return _ElemsIte(_M_buckets[__n + 1]); }
+
+  //static bool _STLP_CALL _M_equal (const _Self&, const _Self&);
+
+public:
+  //The number of buckets is size() - 1 because the last bucket always contains
+  //_M_elems.end() to make algo easier to implement.
+  size_type bucket_count() const { return _M_buckets.size() - 1; }
+  size_type max_bucket_count() const { return _STLP_PRIV _Stl_prime_type::_S_max_nb_buckets(); }
+  size_type elems_in_bucket(size_type __bucket) const
+  { return _STLP_STD::distance(_ElemsIte(_M_buckets[__bucket]), _ElemsIte(_M_buckets[__bucket + 1])); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  size_type bucket(const _KT& __k) const { return _M_bkt_num_key(__k); }
+
+  // hash policy
+  float load_factor() const { return (float)size() / (float)bucket_count(); }
+  float max_load_factor() const { return _M_max_load_factor; }
+  void max_load_factor(float __z) {
+    _M_max_load_factor = __z;
+    _M_resize();
+  }
+
+  pair<iterator, bool> insert_unique(const value_type& __obj) {
+    _M_enlarge(_M_num_elements + 1);
+    return insert_unique_noresize(__obj);
+  }
+
+  iterator insert_equal(const value_type& __obj) {
+    _M_enlarge(_M_num_elements + 1);
+    return insert_equal_noresize(__obj);
+  }
+
+protected:
+  iterator _M_insert_noresize(size_type __n, const value_type& __obj);
+public:
+  pair<iterator, bool> insert_unique_noresize(const value_type& __obj);
+  iterator insert_equal_noresize(const value_type& __obj);
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _InputIterator>
+  void insert_unique(_InputIterator __f, _InputIterator __l)
+  { insert_unique(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIterator)); }
+
+  template <class _InputIterator>
+  void insert_equal(_InputIterator __f, _InputIterator __l)
+  { insert_equal(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIterator)); }
+
+  template <class _InputIterator>
+  void insert_unique(_InputIterator __f, _InputIterator __l,
+                     const input_iterator_tag &) {
+    for ( ; __f != __l; ++__f)
+      insert_unique(*__f);
+  }
+
+  template <class _InputIterator>
+  void insert_equal(_InputIterator __f, _InputIterator __l,
+                    const input_iterator_tag &) {
+    for ( ; __f != __l; ++__f)
+      insert_equal(*__f);
+  }
+
+  template <class _ForwardIterator>
+  void insert_unique(_ForwardIterator __f, _ForwardIterator __l,
+                     const forward_iterator_tag &) {
+    size_type __n = _STLP_STD::distance(__f, __l);
+    _M_enlarge(_M_num_elements + __n);
+    for ( ; __n > 0; --__n, ++__f)
+      insert_unique_noresize(*__f);
+  }
+
+  template <class _ForwardIterator>
+  void insert_equal(_ForwardIterator __f, _ForwardIterator __l,
+                    const forward_iterator_tag &) {
+    size_type __n = _STLP_STD::distance(__f, __l);
+    _M_enlarge(_M_num_elements + __n);
+    for ( ; __n > 0; --__n, ++__f)
+      insert_equal_noresize(*__f);
+  }
+
+#else /* _STLP_MEMBER_TEMPLATES */
+  void insert_unique(const value_type* __f, const value_type* __l) {
+    size_type __n = __l - __f;
+    _M_enlarge(_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;
+    _M_enlarge(_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 = _STLP_STD::distance(__f, __l);
+    _M_enlarge(_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 = _STLP_STD::distance(__f, __l);
+    _M_enlarge(_M_num_elements + __n);
+    for ( ; __n > 0; --__n, ++__f)
+      insert_equal_noresize(*__f);
+  }
+#endif /*_STLP_MEMBER_TEMPLATES */
+
+  //reference find_or_insert(const value_type& __obj);
+
+private:
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  _ElemsIte _M_find(const _KT& __key) const {
+    size_type __n = _M_bkt_num_key(__key);
+    _ElemsIte __first(_M_buckets[__n]);
+    _ElemsIte __last(_M_buckets[__n + 1]);
+    for ( ; (__first != __last) && !_M_equals(_M_get_key(*__first), __key); ++__first) ;
+    if (__first != __last)
+      return __first;
+    else
+      return __CONST_CAST(_ElemsCont&, _M_elems).end();
+  }
+
+public:
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  iterator find(const _KT& __key) { return _M_find(__key); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  const_iterator find(const _KT& __key) const { return _M_find(__key); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  size_type count(const _KT& __key) const {
+    const size_type __n = _M_bkt_num_key(__key);
+
+    _ElemsIte __cur(_M_buckets[__n]);
+    _ElemsIte __last(_M_buckets[__n + 1]);
+    for (; __cur != __last; ++__cur) {
+      if (_M_equals(_M_get_key(*__cur), __key)) {
+        size_type __result = 1;
+        for (++__cur;
+             __cur != __last && _M_equals(_M_get_key(*__cur), __key);
+             ++__result, ++__cur) ;
+        return __result;
+      }
+    }
+    return 0;
+  }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  pair<iterator, iterator> equal_range(const _KT& __key) {
+    typedef pair<iterator, iterator> _Pii;
+    const size_type __n = _M_bkt_num_key(__key);
+
+    for (_ElemsIte __first(_M_buckets[__n]), __last(_M_buckets[__n + 1]);
+         __first != __last; ++__first) {
+      if (_M_equals(_M_get_key(*__first), __key)) {
+        _ElemsIte __cur(__first);
+        for (++__cur; (__cur != __last) && _M_equals(_M_get_key(*__cur), __key); ++__cur) ;
+        return _Pii(__first, __cur);
+      }
+    }
+    return _Pii(end(), end());
+  }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  pair<const_iterator, const_iterator> equal_range(const _KT& __key) const {
+    typedef pair<const_iterator, const_iterator> _Pii;
+    const size_type __n = _M_bkt_num_key(__key);
+
+    for (_ElemsIte __first(_M_buckets[__n]), __last(_M_buckets[__n + 1]);
+         __first != __last; ++__first) {
+      if (_M_equals(_M_get_key(*__first), __key)) {
+        _ElemsIte __cur(__first);
+        for (++__cur; (__cur != __last) && _M_equals(_M_get_key(*__cur), __key); ++__cur) ;
+        return _Pii(__first, __cur);
+      }
+    }
+    return _Pii(end(), end());
+  }
+
+  size_type erase(const key_type& __key);
+  void erase(const_iterator __it);
+  void erase(const_iterator __first, const_iterator __last);
+
+private:
+  void _M_enlarge(size_type __n);
+  void _M_reduce();
+  void _M_resize();
+  void _M_rehash(size_type __num_buckets);
+#if defined (_STLP_DEBUG)
+  void _M_check() const;
+#endif
+
+public:
+  void rehash(size_type __num_buckets_hint);
+  void resize(size_type __num_buckets_hint)
+  { rehash(__num_buckets_hint); }
+  void clear();
+
+  // this is for hash_map::operator[]
+  reference _M_insert(const value_type& __obj);
+
+private:
+  //__n is set to the first bucket that has to be modified if any
+  //erase/insert operation is done after the returned iterator.
+  iterator _M_before_begin(size_type &__n) const;
+
+  static iterator _S_before_begin(const _ElemsCont& __elems, const _BucketVector& __buckets,
+                                  size_type &__n);
+
+  void _M_initialize_buckets(size_type __n) {
+    const size_type __n_buckets = _STLP_PRIV _Stl_prime_type::_S_next_size(__n) + 1;
+    _M_buckets.reserve(__n_buckets);
+    _M_buckets.assign(__n_buckets, __STATIC_CAST(_BucketType*, 0));
+  }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  size_type _M_bkt_num_key(const _KT& __key) const
+  { return _M_bkt_num_key(__key, bucket_count()); }
+
+  size_type _M_bkt_num(const value_type& __obj) const
+  { return _M_bkt_num_key(_M_get_key(__obj)); }
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  size_type _M_bkt_num_key(const _KT& __key, size_type __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); }
+
+  void _M_copy_from(const _Self& __ht);
+};
+
+#if defined (_STLP_DEBUG)
+#  undef hashtable
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+#  include <stl/_hashtable.c>
+#endif
+
+#if defined (_STLP_DEBUG)
+#  include <stl/debug/_hashtable.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#define _STLP_TEMPLATE_HEADER template <class _Val, class _Key, class _HF, class _Traits, class _ExK, class _EqK, class _All>
+#define _STLP_TEMPLATE_CONTAINER hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+#include <stl/_relops_hash_cont.h>
+#undef _STLP_TEMPLATE_CONTAINER
+#undef _STLP_TEMPLATE_HEADER
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Val, class _Key, class _HF, class _Traits, class _ExK, class _EqK, class _All>
+struct __move_traits<hashtable<_Val, _Key, _HF, _Traits, _ExK, _EqK, _All> > {
+  //Hashtables are movable:
+  typedef __true_type implemented;
+
+  //Completeness depends on many template parameters, for the moment we consider it not complete:
+  typedef __false_type complete;
+};
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_HASHTABLE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_heap.c b/stlport/stlport/stl/_heap.c
new file mode 100644
index 0000000..a4ab049
--- /dev/null
+++ b/stlport/stlport/stl/_heap.c
@@ -0,0 +1,246 @@
+/*
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_HEAP_C
+#define _STLP_HEAP_C
+
+#ifndef _STLP_INTERNAL_HEAP_H
+# include <stl/_heap.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_BASE_H
+# include <stl/_iterator_base.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _RandomAccessIterator, class _Distance, class _Tp>
+_STLP_INLINE_LOOP
+void
+__push_heap(_RandomAccessIterator __first,
+            _Distance __holeIndex, _Distance __topIndex, _Tp __val)
+{
+  _Distance __parent = (__holeIndex - 1) / 2;
+  while (__holeIndex > __topIndex && *(__first + __parent) < __val) {
+    *(__first + __holeIndex) = *(__first + __parent);
+    __holeIndex = __parent;
+    __parent = (__holeIndex - 1) / 2;
+  }
+  *(__first + __holeIndex) = __val;
+}
+
+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>
+void
+push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+{
+  __push_heap_aux(__first, __last,
+                  _STLP_DISTANCE_TYPE(__first, _RandomAccessIterator), _STLP_VALUE_TYPE(__first, _RandomAccessIterator));
+}
+
+
+template <class _RandomAccessIterator, class _Distance, class _Tp,
+          class _Compare>
+_STLP_INLINE_LOOP
+void
+__push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+            _Distance __topIndex, _Tp __val, _Compare __comp)
+{
+  _Distance __parent = (__holeIndex - 1) / 2;
+  while (__holeIndex > __topIndex && __comp(*(__first + __parent), __val)) {
+    _STLP_VERBOSE_ASSERT(!__comp(__val, *(__first + __parent)), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+    *(__first + __holeIndex) = *(__first + __parent);
+    __holeIndex = __parent;
+    __parent = (__holeIndex - 1) / 2;
+  }
+  *(__first + __holeIndex) = __val;
+}
+
+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>
+void
+push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+          _Compare __comp)
+{
+  __push_heap_aux(__first, __last, __comp,
+                  _STLP_DISTANCE_TYPE(__first, _RandomAccessIterator), _STLP_VALUE_TYPE(__first, _RandomAccessIterator));
+}
+
+template <class _RandomAccessIterator, class _Distance, class _Tp>
+void
+__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+              _Distance __len, _Tp __val) {
+  _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, __val);
+}
+
+
+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)), _STLP_DISTANCE_TYPE(__first, _RandomAccessIterator));
+}
+
+template <class _RandomAccessIterator>
+void pop_heap(_RandomAccessIterator __first,
+        _RandomAccessIterator __last) {
+  __pop_heap_aux(__first, __last, _STLP_VALUE_TYPE(__first, _RandomAccessIterator));
+}
+
+template <class _RandomAccessIterator, class _Distance,
+          class _Tp, class _Compare>
+void
+__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+              _Distance __len, _Tp __val, _Compare __comp)
+{
+  _Distance __topIndex = __holeIndex;
+  _Distance __secondChild = 2 * __holeIndex + 2;
+  while (__secondChild < __len) {
+    if (__comp(*(__first + __secondChild), *(__first + (__secondChild - 1)))) {
+      _STLP_VERBOSE_ASSERT(!__comp(*(__first + (__secondChild - 1)), *(__first + __secondChild)),
+                           _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+      __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, __val, __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,
+             _STLP_DISTANCE_TYPE(__first, _RandomAccessIterator));
+}
+
+
+template <class _RandomAccessIterator, class _Compare>
+void
+pop_heap(_RandomAccessIterator __first,
+         _RandomAccessIterator __last, _Compare __comp)
+{
+    __pop_heap_aux(__first, __last, _STLP_VALUE_TYPE(__first, _RandomAccessIterator), __comp);
+}
+
+template <class _RandomAccessIterator, class _Tp, class _Distance>
+_STLP_INLINE_LOOP
+void
+__make_heap(_RandomAccessIterator __first,
+            _RandomAccessIterator __last, _Tp*, _Distance*)
+{
+  if (__last - __first < 2) return;
+  _Distance __len = __last - __first;
+  _Distance __parent = (__len - 2)/2;
+
+  for (;;) {
+    __adjust_heap(__first, __parent, __len, _Tp(*(__first + __parent)));
+    if (__parent == 0) return;
+    __parent--;
+  }
+}
+
+template <class _RandomAccessIterator>
+void
+make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+{
+  __make_heap(__first, __last,
+              _STLP_VALUE_TYPE(__first, _RandomAccessIterator), _STLP_DISTANCE_TYPE(__first, _RandomAccessIterator));
+}
+
+template <class _RandomAccessIterator, class _Compare,
+          class _Tp, class _Distance>
+_STLP_INLINE_LOOP
+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;
+
+  for (;;) {
+    __adjust_heap(__first, __parent, __len, _Tp(*(__first + __parent)),
+                  __comp);
+    if (__parent == 0) return;
+    __parent--;
+  }
+}
+
+template <class _RandomAccessIterator, class _Compare>
+void
+make_heap(_RandomAccessIterator __first,
+          _RandomAccessIterator __last, _Compare __comp)
+{
+  __make_heap(__first, __last, __comp,
+              _STLP_VALUE_TYPE(__first, _RandomAccessIterator), _STLP_DISTANCE_TYPE(__first, _RandomAccessIterator));
+}
+
+_STLP_END_NAMESPACE
+
+#endif /*  _STLP_HEAP_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_heap.h b/stlport/stlport/stl/_heap.h
new file mode 100644
index 0000000..016dc49
--- /dev/null
+++ b/stlport/stlport/stl/_heap.h
@@ -0,0 +1,125 @@
+/*
+ *
+ * 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 _STLP_INTERNAL_HEAP_H
+#define _STLP_INTERNAL_HEAP_H
+
+_STLP_BEGIN_NAMESPACE
+
+// Heap-manipulation functions: push_heap, pop_heap, make_heap, sort_heap.
+
+template <class _RandomAccessIterator>
+void
+push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last);
+
+
+template <class _RandomAccessIterator, class _Compare>
+void
+push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+          _Compare __comp);
+
+template <class _RandomAccessIterator, class _Distance, class _Tp>
+void
+__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+              _Distance __len, _Tp __val);
+
+template <class _RandomAccessIterator, class _Tp, class _Distance>
+inline void
+__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+           _RandomAccessIterator __result, _Tp __val, _Distance*)
+{
+  *__result = *__first;
+  __adjust_heap(__first, _Distance(0), _Distance(__last - __first), __val);
+}
+
+template <class _RandomAccessIterator>
+void pop_heap(_RandomAccessIterator __first,
+        _RandomAccessIterator __last);
+
+template <class _RandomAccessIterator, class _Distance,
+          class _Tp, class _Compare>
+void
+__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+              _Distance __len, _Tp __val, _Compare __comp);
+
+template <class _RandomAccessIterator, class _Tp, class _Compare,
+          class _Distance>
+inline void
+__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+           _RandomAccessIterator __result, _Tp __val, _Compare __comp,
+           _Distance*)
+{
+  *__result = *__first;
+  __adjust_heap(__first, _Distance(0), _Distance(__last - __first),
+                __val, __comp);
+}
+
+template <class _RandomAccessIterator, class _Compare>
+void
+pop_heap(_RandomAccessIterator __first,
+         _RandomAccessIterator __last, _Compare __comp);
+
+template <class _RandomAccessIterator>
+void
+make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last);
+
+template <class _RandomAccessIterator, class _Compare>
+void
+make_heap(_RandomAccessIterator __first,
+          _RandomAccessIterator __last, _Compare __comp);
+
+template <class _RandomAccessIterator>
+_STLP_INLINE_LOOP
+void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+{
+  while (__last - __first > 1)
+    pop_heap(__first, __last--);
+}
+
+template <class _RandomAccessIterator, class _Compare>
+_STLP_INLINE_LOOP
+void
+sort_heap(_RandomAccessIterator __first,
+          _RandomAccessIterator __last, _Compare __comp)
+{
+  while (__last - __first > 1)
+    pop_heap(__first, __last--, __comp);
+}
+
+_STLP_END_NAMESPACE
+
+# if !defined (_STLP_LINK_TIME_INSTANTIATION)
+#  include <stl/_heap.c>
+# endif
+
+#endif /* _STLP_INTERNAL_HEAP_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_iosfwd.h b/stlport/stlport/stl/_iosfwd.h
new file mode 100644
index 0000000..e31db31
--- /dev/null
+++ b/stlport/stlport/stl/_iosfwd.h
@@ -0,0 +1,159 @@
+#ifndef _STLP_INTERNAL_IOSFWD
+#define _STLP_INTERNAL_IOSFWD
+
+#if defined (__sgi) && !defined (__GNUC__) && !defined (_STANDARD_C_PLUS_PLUS)
+#  error This header file requires the -LANG:std option
+#endif
+
+// This file provides forward declarations of the most important I/O
+// classes.  Note that almost all of those classes are class templates,
+// with default template arguments.  According to the C++ standard,
+// if a class template is declared more than once in the same scope
+// then only one of those declarations may have default arguments.
+
+// <iosfwd> contains the same declarations as other headers, and including
+// both <iosfwd> and (say) <iostream> is permitted.  This means that only
+// one header may contain those default template arguments.
+
+// In this implementation, the declarations in <iosfwd> contain default
+// template arguments.  All of the other I/O headers include <iosfwd>.
+
+#ifndef _STLP_CHAR_TRAITS_H
+#  include <stl/char_traits.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+class ios_base;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class basic_ios;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class basic_streambuf;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class basic_istream;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class basic_ostream;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class basic_iostream;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM( _Traits , char_traits<_CharT>),
+          _STLP_DFL_TMPL_PARAM(_Allocator , allocator<_CharT>) >
+class basic_stringbuf;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>),
+          _STLP_DFL_TMPL_PARAM(_Allocator , allocator<_CharT>) >
+class basic_istringstream;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>),
+          _STLP_DFL_TMPL_PARAM(_Allocator , allocator<_CharT>) >
+class basic_ostringstream;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>),
+          _STLP_DFL_TMPL_PARAM(_Allocator , allocator<_CharT>) >
+class basic_stringstream;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class basic_filebuf;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class basic_ifstream;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class basic_ofstream;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class basic_fstream;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class istreambuf_iterator;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class ostreambuf_iterator;
+
+typedef basic_ios<char, char_traits<char> >    ios;
+
+#if !defined (_STLP_NO_WCHAR_T)
+typedef basic_ios<wchar_t, char_traits<wchar_t> > wios;
+#endif
+
+// Forward declaration of class locale, and of the most important facets.
+class locale;
+template <class _Facet>
+#if defined (_STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS)
+struct _Use_facet {
+  const locale& __loc;
+  _Use_facet(const locale& __p_loc) : __loc(__p_loc) {}
+  inline const _Facet& operator *() const;
+};
+#  define use_facet *_Use_facet
+#else
+inline const _Facet& use_facet(const locale&);
+#endif
+
+template <class _CharT> class ctype;
+template <class _CharT> class ctype_byname;
+template <class _CharT> class collate;
+template <class _CharT> class collate_byname;
+
+_STLP_TEMPLATE_NULL class ctype<char>;
+_STLP_TEMPLATE_NULL class ctype_byname<char>;
+_STLP_TEMPLATE_NULL class collate<char>;
+_STLP_TEMPLATE_NULL class collate_byname<char>;
+
+#if !defined (_STLP_NO_WCHAR_T)
+_STLP_TEMPLATE_NULL class ctype<wchar_t>;
+_STLP_TEMPLATE_NULL class ctype_byname<wchar_t>;
+_STLP_TEMPLATE_NULL class collate<wchar_t>;
+_STLP_TEMPLATE_NULL class collate_byname<wchar_t>;
+#endif
+
+#if !(defined (__SUNPRO_CC) && __SUNPRO_CC < 0x500 )
+// Typedefs for ordinary (narrow-character) streams.
+//_STLP_TEMPLATE_NULL class basic_streambuf<char, char_traits<char> >;
+#endif
+
+typedef basic_istream<char, char_traits<char> >  istream;
+typedef basic_ostream<char, char_traits<char> >  ostream;
+typedef basic_iostream<char, char_traits<char> > iostream;
+typedef basic_streambuf<char,char_traits<char> > streambuf;
+
+typedef basic_stringbuf<char, char_traits<char>, allocator<char> >     stringbuf;
+typedef basic_istringstream<char, char_traits<char>, allocator<char> > istringstream;
+typedef basic_ostringstream<char, char_traits<char>, allocator<char> > ostringstream;
+typedef basic_stringstream<char, char_traits<char>, allocator<char> >  stringstream;
+
+typedef basic_filebuf<char, char_traits<char> >  filebuf;
+typedef basic_ifstream<char, char_traits<char> > ifstream;
+typedef basic_ofstream<char, char_traits<char> > ofstream;
+typedef basic_fstream<char, char_traits<char> >  fstream;
+
+#if !defined (_STLP_NO_WCHAR_T)
+// Typedefs for wide-character streams.
+typedef basic_streambuf<wchar_t, char_traits<wchar_t> > wstreambuf;
+typedef basic_istream<wchar_t, char_traits<wchar_t> >   wistream;
+typedef basic_ostream<wchar_t, char_traits<wchar_t> >   wostream;
+typedef basic_iostream<wchar_t, char_traits<wchar_t> >  wiostream;
+
+typedef basic_stringbuf<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >     wstringbuf;
+typedef basic_istringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > wistringstream;
+typedef basic_ostringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > wostringstream;
+typedef basic_stringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >  wstringstream;
+
+typedef basic_filebuf<wchar_t, char_traits<wchar_t> >  wfilebuf;
+typedef basic_ifstream<wchar_t, char_traits<wchar_t> > wifstream;
+typedef basic_ofstream<wchar_t, char_traits<wchar_t> > wofstream;
+typedef basic_fstream<wchar_t, char_traits<wchar_t> >  wfstream;
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_limits.c b/stlport/stlport/stl/_limits.c
new file mode 100644
index 0000000..3938024
--- /dev/null
+++ b/stlport/stlport/stl/_limits.c
@@ -0,0 +1,405 @@
+/*
+ * Copyright (c) 1998,1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_LIMITS_C
+#define _STLP_LIMITS_C
+
+#ifndef _STLP_INTERNAL_LIMITS
+#  include <stl/_limits.h>
+#endif
+
+//==========================================================
+//  numeric_limits static members
+//==========================================================
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+#if !defined (_STLP_STATIC_CONST_INIT_BUG) && !defined (_STLP_NO_STATIC_CONST_DEFINITION)
+
+#  define __declare_numeric_base_member(__type, __mem) \
+template <class __number> \
+  const __type _Numeric_limits_base<__number>:: __mem
+
+__declare_numeric_base_member(bool, is_specialized);
+__declare_numeric_base_member(int, digits);
+__declare_numeric_base_member(int, digits10);
+__declare_numeric_base_member(bool, is_signed);
+__declare_numeric_base_member(bool, is_integer);
+__declare_numeric_base_member(bool, is_exact);
+__declare_numeric_base_member(int, radix);
+__declare_numeric_base_member(int, min_exponent);
+__declare_numeric_base_member(int, max_exponent);
+__declare_numeric_base_member(int, min_exponent10);
+__declare_numeric_base_member(int, max_exponent10);
+__declare_numeric_base_member(bool, has_infinity);
+__declare_numeric_base_member(bool, has_quiet_NaN);
+__declare_numeric_base_member(bool, has_signaling_NaN);
+__declare_numeric_base_member(float_denorm_style, has_denorm);
+__declare_numeric_base_member(bool, has_denorm_loss);
+__declare_numeric_base_member(bool, is_iec559);
+__declare_numeric_base_member(bool, is_bounded);
+__declare_numeric_base_member(bool, is_modulo);
+__declare_numeric_base_member(bool, traps);
+__declare_numeric_base_member(bool, tinyness_before);
+__declare_numeric_base_member(float_round_style, round_style);
+
+#  undef __declare_numeric_base_member
+
+#  define __declare_integer_limits_member(__type, __mem) \
+template <class _Int, _STLP_LIMITS_MIN_TYPE __imin, _STLP_LIMITS_MAX_TYPE __imax, int __idigits, bool __ismod> \
+  const __type _Integer_limits<_Int, __imin, __imax, __idigits, __ismod>:: __mem
+
+__declare_integer_limits_member(bool, is_specialized);
+__declare_integer_limits_member(int, digits);
+__declare_integer_limits_member(int, digits10);
+__declare_integer_limits_member(bool, is_signed);
+__declare_integer_limits_member(bool, is_integer);
+__declare_integer_limits_member(bool, is_exact);
+__declare_integer_limits_member(int, radix);
+__declare_integer_limits_member(bool, is_bounded);
+__declare_integer_limits_member(bool, is_modulo);
+#  undef __declare_integer_limits_member
+
+#  if defined (__GNUC__) && (__GNUC__ != 2 || __GNUC_MINOR__ > 96) && (__GNUC__ != 3 || __GNUC_MINOR__ == 0) && (__GNUC__ <= 3)
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#    define __declare_numeric_limits_member(__integer) \
+  _STLP_TEMPLATE_NULL const int numeric_limits<__integer>::digits; \
+  _STLP_TEMPLATE_NULL const int numeric_limits<__integer>::digits10; \
+  _STLP_TEMPLATE_NULL const int numeric_limits<__integer>::radix; \
+  _STLP_TEMPLATE_NULL const bool numeric_limits<__integer>::is_specialized; \
+  _STLP_TEMPLATE_NULL const bool numeric_limits<__integer>::is_signed; \
+  _STLP_TEMPLATE_NULL const bool numeric_limits<__integer>::is_integer; \
+  _STLP_TEMPLATE_NULL const bool numeric_limits<__integer>::is_exact; \
+  _STLP_TEMPLATE_NULL const bool numeric_limits<__integer>::is_bounded; \
+  _STLP_TEMPLATE_NULL const bool numeric_limits<__integer>::is_modulo
+
+__declare_numeric_limits_member(_STLP_LONG_LONG);
+__declare_numeric_limits_member(unsigned _STLP_LONG_LONG);
+
+#    undef __declare_numeric_limits_member
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#  endif
+
+#  define __declare_float_limits_member(__type, __mem) \
+template <class __number,  \
+         int __Digits, int __Digits10,    \
+         int __MinExp, int __MaxExp,      \
+         int __MinExp10, int __MaxExp10,  \
+         bool __IsIEC559, \
+         float_denorm_style __DenormStyle, \
+         float_round_style __RoundStyle> \
+const __type _Floating_limits< __number, __Digits, __Digits10,    \
+         __MinExp, __MaxExp, __MinExp10, __MaxExp10,  \
+         __IsIEC559, __DenormStyle, __RoundStyle>::\
+         __mem
+
+__declare_float_limits_member(bool, is_specialized);
+__declare_float_limits_member(int, digits);
+__declare_float_limits_member(int, digits10);
+__declare_float_limits_member(bool, is_signed);
+__declare_float_limits_member(int, radix);
+__declare_float_limits_member(int, min_exponent);
+__declare_float_limits_member(int, max_exponent);
+__declare_float_limits_member(int, min_exponent10);
+__declare_float_limits_member(int, max_exponent10);
+__declare_float_limits_member(bool, has_infinity);
+__declare_float_limits_member(bool, has_quiet_NaN);
+__declare_float_limits_member(bool, has_signaling_NaN);
+__declare_float_limits_member(float_denorm_style, has_denorm);
+__declare_float_limits_member(bool, has_denorm_loss);
+__declare_float_limits_member(bool, is_iec559);
+__declare_float_limits_member(bool, is_bounded);
+__declare_float_limits_member(bool, traps);
+__declare_float_limits_member(bool, tinyness_before);
+__declare_float_limits_member(float_round_style, round_style);
+#  undef __declare_float_limits_member
+
+#endif
+
+
+#if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)
+
+#  if defined (__GNUC__) || defined (__BORLANDC__)
+#    define _STLP_ADDITIONAL_OPEN_BRACKET {
+#    define _STLP_ADDITIONAL_CLOSE_BRACKET }
+#  else
+#    define _STLP_ADDITIONAL_OPEN_BRACKET
+#    define _STLP_ADDITIONAL_CLOSE_BRACKET
+#  endif
+
+/* The following code has been extracted from the boost libraries (www.boost.org) and
+ * adapted with the STLport portability macros. Advantage on previous technique is that
+ * computation of infinity and NaN values is only based on big/little endianess, compiler
+ * float, double or long double representation is taken into account thanks to the sizeof
+ * operator. */
+template<class _Number, unsigned short _Word>
+struct float_helper {
+  union _WordsNumber {
+    unsigned short _Words[8];
+    _Number _num;
+  };
+  static _Number get_word_higher() _STLP_NOTHROW {
+    _WordsNumber __tmp = { _STLP_ADDITIONAL_OPEN_BRACKET _Word, 0, 0, 0, 0, 0, 0, 0 _STLP_ADDITIONAL_CLOSE_BRACKET };
+    return __tmp._num;
+  } 
+  static _Number get_word_lower() _STLP_NOTHROW {
+    _WordsNumber __tmp = { _STLP_ADDITIONAL_OPEN_BRACKET 0, 0, 0, 0, 0, 0, 0, 0 _STLP_ADDITIONAL_CLOSE_BRACKET };
+    __tmp._Words[(sizeof(_Number) >= 12 ? 10 : sizeof(_Number)) / sizeof(unsigned short) - 1] = _Word;
+    return __tmp._num;
+  }
+  static _Number get_from_last_word() _STLP_NOTHROW {
+#  if defined (_STLP_BIG_ENDIAN)
+    return get_word_higher();
+#  else /* _STLP_LITTLE_ENDIAN */
+    return get_word_lower();
+#  endif
+  }
+  static _Number get_from_first_word() _STLP_NOTHROW {
+#  if defined (_STLP_BIG_ENDIAN)
+    return get_word_lower();
+#  else /* _STLP_LITTLE_ENDIAN */
+    return get_word_higher();
+#  endif
+  }
+};
+
+#  if !defined (_STLP_NO_LONG_DOUBLE) && !defined (_STLP_BIG_ENDIAN)
+template<class _Number, unsigned short _Word1, unsigned short _Word2>
+struct float_helper2 {
+  union _WordsNumber {
+    unsigned short _Words[8];
+    _Number _num;
+  };
+  //static _Number get_word_higher() _STLP_NOTHROW {
+  //  _WordsNumber __tmp = { _STLP_ADDITIONAL_OPEN_BRACKET _Word1, _Word2, 0, 0, 0, 0, 0, 0 _STLP_ADDITIONAL_CLOSE_BRACKET };
+  //  return __tmp._num;
+  //} 
+  static _Number get_word_lower() _STLP_NOTHROW {
+    _WordsNumber __tmp = { _STLP_ADDITIONAL_OPEN_BRACKET 0, 0, 0, 0, 0, 0, 0, 0 _STLP_ADDITIONAL_CLOSE_BRACKET };
+    __tmp._Words[(sizeof(_Number) >= 12 ? 10 : sizeof(_Number)) / sizeof(unsigned short) - 2] = _Word1;
+    __tmp._Words[(sizeof(_Number) >= 12 ? 10 : sizeof(_Number)) / sizeof(unsigned short) - 1] = _Word2;
+    return __tmp._num;
+  }
+  static _Number get_from_last_word() _STLP_NOTHROW {
+//#    if defined (_STLP_BIG_ENDIAN)
+//    return get_word_higher();
+//#    else /* _STLP_LITTLE_ENDIAN */
+    return get_word_lower();
+//#    endif
+  }
+};
+#  endif
+
+/* Former values kept in case moving to boost code has introduce a regression on
+ * some platform. */
+#if 0
+#  if defined (_STLP_BIG_ENDIAN)
+#    if defined (__OS400__)
+#      define _STLP_FLOAT_INF_REP { 0x7f80, 0 }
+#      define _STLP_FLOAT_QNAN_REP { 0xffc0, 0 }
+#      define _STLP_FLOAT_SNAN_REP { 0xff80, 0 }
+#      define _STLP_DOUBLE_INF_REP { 0x7ff0, 0, 0, 0 }
+#      define _STLP_DOUBLE_QNAN_REP { 0xfff8, 0, 0, 0 }
+#      define _STLP_DOUBLE_SNAN_REP { 0xfff0, 0, 0, 0 }
+#      define _STLP_LDOUBLE_INF_REP { 0x7ff0, 0, 0, 0, 0, 0, 0, 0 }
+#      define _STLP_LDOUBLE_QNAN_REP { 0xfff8, 0, 0, 0, 0, 0, 0, 0 }
+#      define _STLP_LDOUBLE_SNAN_REP { 0xfff0, 0, 0, 0, 0, 0, 0, 0 }
+#    else /* __OS400__ */
+#      define _STLP_FLOAT_INF_REP   { 0x7f80, 0 }
+#      define _STLP_FLOAT_QNAN_REP  { 0x7fc1, 0 }
+#      define _STLP_FLOAT_SNAN_REP  { 0x7f81, 0 }
+#      define _STLP_DOUBLE_INF_REP  { 0x7ff0, 0, 0, 0 }
+#      define _STLP_DOUBLE_QNAN_REP { 0x7ff9, 0, 0, 0 }
+#      define _STLP_DOUBLE_SNAN_REP { 0x7ff1, 0, 0, 0 }
+#      define _STLP_LDOUBLE_INF_REP { 0x7ff0, 0, 0, 0, 0, 0, 0, 0 }
+#      define _STLP_LDOUBLE_QNAN_REP { 0x7ff1, 0, 0, 0, 0, 0, 0, 0 }
+#      define _STLP_LDOUBLE_SNAN_REP { 0x7ff9, 0, 0, 0, 0, 0, 0, 0 }
+#    endif /* __OS400__ */
+#  else /* _STLP_LITTLE_ENDIAN */
+#    if defined(__DECCXX)
+#      define _STLP_FLOAT_INF_REP { 0, 0x7f80 }
+#      define _STLP_FLOAT_QNAN_REP { 0, 0xffc0 }
+#      define _STLP_FLOAT_SNAN_REP { 0x5555, 0x7f85 }
+#      define _STLP_DOUBLE_INF_REP { 0, 0, 0, 0x7ff0 }
+#      define _STLP_DOUBLE_QNAN_REP { 0, 0, 0, 0xfff8 }
+#      define _STLP_DOUBLE_SNAN_REP { 0x5555, 0x5555, 0x5555, 0x7ff5 }
+#      define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0, 0, 0, 0, 0x7fff }
+#      define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0, 0, 0, 0x8000, 0xffff }
+#      define _STLP_LDOUBLE_SNAN_REP { 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x7fff}
+#    else
+#      define _STLP_FLOAT_INF_REP { 0, 0x7f80 }
+#      define _STLP_FLOAT_QNAN_REP { 0, 0x7fc0 }
+#      define _STLP_FLOAT_SNAN_REP { 0, 0x7fa0 }
+#      define _STLP_DOUBLE_INF_REP { 0, 0, 0, 0x7ff0 }
+#      define _STLP_DOUBLE_QNAN_REP { 0, 0, 0, 0x7ff8 }
+#      define _STLP_DOUBLE_SNAN_REP { 0, 0, 0, 0x7ff4 }
+#      if defined (_STLP_MSVC) || defined (__ICL)
+#        define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x7FF0, 0 }
+#        define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xFFF8, 0 }
+#        define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xFFF8, 0 }
+#      elif defined (__BORLANDC__)
+#        define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x8000, 0x7fff }
+#        define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xc000, 0x7fff }
+#        define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xa000, 0x7fff }
+#      else
+#        define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x8000, 0x7fff, 0 }
+#        define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xa000, 0x7fff, 0 }
+#        define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xc000, 0x7fff, 0 }
+#      endif
+#    endif
+#  endif
+
+union _F_rep {
+  unsigned short rep[2];
+  float val;
+};
+union _D_rep {
+  unsigned short rep[4];
+  double val;
+};
+
+#  ifndef _STLP_NO_LONG_DOUBLE
+union _LD_rep {
+  unsigned short rep[8];
+  long double val;
+};
+#  endif
+#endif
+
+template <class __dummy>
+float _STLP_CALL _LimG<__dummy>::get_F_inf() {
+  typedef float_helper<float, 0x7f80u> _FloatHelper;
+  return _FloatHelper::get_from_last_word();
+}
+template <class __dummy>
+float _STLP_CALL _LimG<__dummy>::get_F_qNaN() {
+  typedef float_helper<float, 0x7f81u> _FloatHelper;
+  return _FloatHelper::get_from_last_word();
+}
+template <class __dummy>
+float _STLP_CALL _LimG<__dummy>::get_F_sNaN() {
+  typedef float_helper<float, 0x7fc1u> _FloatHelper;
+  return _FloatHelper::get_from_last_word();
+}
+template <class __dummy>
+float _STLP_CALL _LimG<__dummy>::get_F_denormMin() {
+  typedef float_helper<float, 0x0001u> _FloatHelper;
+  return _FloatHelper::get_from_first_word();
+}
+
+template <int __use_double_limits>
+class _NumericLimitsAccess;
+
+_STLP_TEMPLATE_NULL
+class _NumericLimitsAccess<1> {
+public:
+  static double get_inf() {
+    typedef float_helper<double, 0x7ff0u> _FloatHelper;
+    return _FloatHelper::get_from_last_word();
+  }
+  static double get_qNaN() {
+    typedef float_helper<double, 0x7ff1u> _FloatHelper;
+    return _FloatHelper::get_from_last_word();
+  }
+  static double get_sNaN() {
+    typedef float_helper<double, 0x7ff9u> _FloatHelper;
+    return _FloatHelper::get_from_last_word();
+  }
+};
+
+template <class __dummy>
+double _STLP_CALL _LimG<__dummy>::get_D_inf()
+{ return _NumericLimitsAccess<1>::get_inf(); }
+template <class __dummy>
+double _STLP_CALL _LimG<__dummy>::get_D_qNaN()
+{ return _NumericLimitsAccess<1>::get_qNaN(); }
+template <class __dummy>
+double _STLP_CALL _LimG<__dummy>::get_D_sNaN()
+{ return _NumericLimitsAccess<1>::get_sNaN(); }
+template <class __dummy>
+double _STLP_CALL _LimG<__dummy>::get_D_denormMin() {
+  typedef float_helper<double, 0x0001u> _FloatHelper;
+  return _FloatHelper::get_from_first_word();
+}
+
+#  if !defined (_STLP_NO_LONG_DOUBLE)
+_STLP_TEMPLATE_NULL
+class _NumericLimitsAccess<0> {
+public:
+  static long double get_inf() {
+#    if defined (_STLP_BIG_ENDIAN)
+    typedef float_helper<long double, 0x7ff0u> _FloatHelper;
+#    else
+    typedef float_helper2<long double, 0x8000u, 0x7fffu> _FloatHelper;
+#    endif
+    return _FloatHelper::get_from_last_word();
+  }
+  static long double get_qNaN() {
+#    if defined (_STLP_BIG_ENDIAN)
+    typedef float_helper<long double, 0x7ff1u> _FloatHelper;
+#    else
+    typedef float_helper2<long double, 0xc000u, 0x7fffu> _FloatHelper;
+#    endif
+    return _FloatHelper::get_from_last_word();
+  }
+  static long double get_sNaN() {
+#    if defined (_STLP_BIG_ENDIAN)
+    typedef float_helper<long double, 0x7ff9u> _FloatHelper;
+#    else
+    typedef float_helper2<long double, 0x9000u, 0x7fffu> _FloatHelper;
+#    endif
+    return _FloatHelper::get_from_last_word();
+  }
+};
+
+template <class __dummy>
+long double _STLP_CALL _LimG<__dummy>::get_LD_inf() {
+  const int __use_double_limits = sizeof(double) == sizeof(long double) ? 1 : 0;
+  return _NumericLimitsAccess<__use_double_limits>::get_inf();
+}
+template <class __dummy>
+long double _STLP_CALL _LimG<__dummy>::get_LD_qNaN() {
+  const int __use_double_limits = sizeof(double) == sizeof(long double) ? 1 : 0;
+  return _NumericLimitsAccess<__use_double_limits>::get_qNaN();
+}
+template <class __dummy>
+long double _STLP_CALL _LimG<__dummy>::get_LD_sNaN() {
+  const int __use_double_limits = sizeof(double) == sizeof(long double) ? 1 : 0;
+  return _NumericLimitsAccess<__use_double_limits>::get_sNaN();
+}
+template <class __dummy>
+long double _STLP_CALL _LimG<__dummy>::get_LD_denormMin() {
+  typedef float_helper<long double, 0x0001u> _FloatHelper;
+  return _FloatHelper::get_from_first_word();
+}
+#  endif
+
+#endif /* _STLP_EXPOSE_GLOBALS_IMPLEMENTATION */
+
+#undef _STLP_LIMITS_MIN_TYPE
+#undef _STLP_LIMITS_MAX_TYPE
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_LIMITS_C_INCLUDED */
diff --git a/stlport/stlport/stl/_limits.h b/stlport/stlport/stl/_limits.h
new file mode 100644
index 0000000..c0091f6
--- /dev/null
+++ b/stlport/stlport/stl/_limits.h
@@ -0,0 +1,519 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This may be not portable code. Parts of numeric_limits<> are
+ * inherently machine-dependent.  At present this file is suitable
+ * for the MIPS, SPARC, Alpha and ia32 architectures.
+ */
+
+#ifndef _STLP_INTERNAL_LIMITS
+#define _STLP_INTERNAL_LIMITS
+
+#ifndef _STLP_CLIMITS
+#  include <climits>
+#endif
+
+#ifndef _STLP_CFLOAT
+#  include <cfloat>
+#endif
+
+#if defined (_STLP_HAS_WCHAR_T) && !defined (_STLP_INTERNAL_CWCHAR)
+#  include <stl/_cwchar.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+enum float_round_style {
+  round_indeterminate       = -1,
+  round_toward_zero         =  0,
+  round_to_nearest          =  1,
+  round_toward_infinity     =  2,
+  round_toward_neg_infinity =  3
+};
+
+enum float_denorm_style {
+  denorm_indeterminate = -1,
+  denorm_absent        =  0,
+  denorm_present       =  1
+};
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// Base class for all specializations of numeric_limits.
+template <class __number>
+class _Numeric_limits_base {
+public:
+
+  static __number (_STLP_CALL min)() _STLP_NOTHROW { return __number(); }
+  static __number (_STLP_CALL max)() _STLP_NOTHROW { return __number(); }
+
+  _STLP_STATIC_CONSTANT(int, digits = 0);
+  _STLP_STATIC_CONSTANT(int, digits10 = 0);
+  _STLP_STATIC_CONSTANT(int, radix = 0);
+  _STLP_STATIC_CONSTANT(int, min_exponent = 0);
+  _STLP_STATIC_CONSTANT(int, min_exponent10 = 0);
+  _STLP_STATIC_CONSTANT(int, max_exponent = 0);
+  _STLP_STATIC_CONSTANT(int, max_exponent10 = 0);
+
+  _STLP_STATIC_CONSTANT(float_denorm_style, has_denorm = denorm_absent);
+  _STLP_STATIC_CONSTANT(float_round_style, round_style = round_toward_zero);
+
+  _STLP_STATIC_CONSTANT(bool, is_specialized = false);
+  _STLP_STATIC_CONSTANT(bool, is_signed  = false);
+  _STLP_STATIC_CONSTANT(bool, is_integer = false);
+  _STLP_STATIC_CONSTANT(bool, is_exact = false);
+  _STLP_STATIC_CONSTANT(bool, has_infinity = false);
+  _STLP_STATIC_CONSTANT(bool, has_quiet_NaN = false);
+  _STLP_STATIC_CONSTANT(bool, has_signaling_NaN = false);
+  _STLP_STATIC_CONSTANT(bool, has_denorm_loss = false);
+  _STLP_STATIC_CONSTANT(bool, is_iec559 = false);
+  _STLP_STATIC_CONSTANT(bool, is_bounded = false);
+  _STLP_STATIC_CONSTANT(bool, is_modulo = false);
+  _STLP_STATIC_CONSTANT(bool, traps = false);
+  _STLP_STATIC_CONSTANT(bool, tinyness_before = false);
+
+  static __number _STLP_CALL epsilon() _STLP_NOTHROW     { return __number(); }
+  static __number _STLP_CALL round_error() _STLP_NOTHROW { return __number(); }
+
+  static __number _STLP_CALL infinity() _STLP_NOTHROW      { return __number(); }
+  static __number _STLP_CALL quiet_NaN() _STLP_NOTHROW     { return __number(); }
+  static __number _STLP_CALL signaling_NaN() _STLP_NOTHROW { return __number(); }
+  static __number _STLP_CALL denorm_min() _STLP_NOTHROW    { return __number(); }
+};
+
+// Base class for integers.
+
+#ifdef _STLP_LIMITED_DEFAULT_TEMPLATES
+#  ifdef _STLP_LONG_LONG
+#    define _STLP_LIMITS_MIN_TYPE _STLP_LONG_LONG
+#    define _STLP_LIMITS_MAX_TYPE unsigned _STLP_LONG_LONG
+#  else
+#    define _STLP_LIMITS_MIN_TYPE long
+#    define _STLP_LIMITS_MAX_TYPE unsigned long
+#  endif
+#else
+#  define _STLP_LIMITS_MIN_TYPE _Int
+#  define _STLP_LIMITS_MAX_TYPE _Int
+#endif /* _STLP_LIMITED_DEFAULT_TEMPLATES */
+
+template <class _Int,
+          _STLP_LIMITS_MIN_TYPE __imin,
+          _STLP_LIMITS_MAX_TYPE __imax,
+          int __idigits, bool __ismod>
+class _Integer_limits : public _Numeric_limits_base<_Int> {
+public:
+
+  static _Int (_STLP_CALL min) () _STLP_NOTHROW { return (_Int)__imin; }
+  static _Int (_STLP_CALL max) () _STLP_NOTHROW { return (_Int)__imax; }
+
+  _STLP_STATIC_CONSTANT(int, digits = (__idigits < 0) ? ((int)((sizeof(_Int) * (CHAR_BIT))) - ((__imin == 0) ? 0 : 1)) : (__idigits));
+  _STLP_STATIC_CONSTANT(int, digits10 = (digits * 301UL) / 1000);
+  _STLP_STATIC_CONSTANT(int, radix = 2);
+  _STLP_STATIC_CONSTANT(bool, is_specialized = true);
+  _STLP_STATIC_CONSTANT(bool, is_signed = (__imin != 0));
+  _STLP_STATIC_CONSTANT(bool, is_integer = true);
+  _STLP_STATIC_CONSTANT(bool, is_exact = true);
+  _STLP_STATIC_CONSTANT(bool, is_bounded = true);
+  _STLP_STATIC_CONSTANT(bool, is_modulo = __ismod);
+};
+
+// Base class for floating-point numbers.
+template <class __number,
+         int __Digits, int __Digits10,
+         int __MinExp, int __MaxExp,
+         int __MinExp10, int __MaxExp10,
+         bool __IsIEC559,
+         float_denorm_style __DenormStyle,
+         float_round_style __RoundStyle>
+class _Floating_limits : public _Numeric_limits_base<__number> {
+public:
+
+  _STLP_STATIC_CONSTANT(int, digits = __Digits);
+  _STLP_STATIC_CONSTANT(int, digits10 = __Digits10);
+  _STLP_STATIC_CONSTANT(int, radix = FLT_RADIX);
+  _STLP_STATIC_CONSTANT(int, min_exponent = __MinExp);
+  _STLP_STATIC_CONSTANT(int, max_exponent = __MaxExp);
+  _STLP_STATIC_CONSTANT(int, min_exponent10 = __MinExp10);
+  _STLP_STATIC_CONSTANT(int, max_exponent10 = __MaxExp10);
+
+  _STLP_STATIC_CONSTANT(float_denorm_style, has_denorm = __DenormStyle);
+  _STLP_STATIC_CONSTANT(float_round_style, round_style = __RoundStyle);
+
+  _STLP_STATIC_CONSTANT(bool, is_specialized = true);
+  _STLP_STATIC_CONSTANT(bool, is_signed = true);
+
+  _STLP_STATIC_CONSTANT(bool, has_infinity = true);
+#if (!defined (_STLP_MSVC) || (_STLP_MSVC > 1300)) && \
+    (!defined (__BORLANDC__) || (__BORLANDC__ >= 0x590)) && \
+    (!defined (_CRAY) || defined (_CRAYIEEE))
+  _STLP_STATIC_CONSTANT(bool, has_quiet_NaN = true);
+  _STLP_STATIC_CONSTANT(bool, has_signaling_NaN = true);
+#else
+  _STLP_STATIC_CONSTANT(bool, has_quiet_NaN = false);
+  _STLP_STATIC_CONSTANT(bool, has_signaling_NaN = false);
+#endif
+
+  _STLP_STATIC_CONSTANT(bool, is_iec559 = __IsIEC559 && has_infinity && has_quiet_NaN && has_signaling_NaN && (has_denorm == denorm_present));
+  _STLP_STATIC_CONSTANT(bool, has_denorm_loss =  false);
+  _STLP_STATIC_CONSTANT(bool, is_bounded = true);
+  _STLP_STATIC_CONSTANT(bool, traps = true);
+  _STLP_STATIC_CONSTANT(bool, tinyness_before = false);
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+// Class numeric_limits
+
+// The unspecialized class.
+
+template<class _Tp>
+class numeric_limits : public _STLP_PRIV _Numeric_limits_base<_Tp> {};
+
+// Specializations for all built-in integral types.
+
+#if !defined (_STLP_NO_BOOL)
+_STLP_TEMPLATE_NULL
+class numeric_limits<bool>
+  : public _STLP_PRIV _Integer_limits<bool, false, true, 1, false>
+{};
+#endif /* _STLP_NO_BOOL */
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<char>
+  : public _STLP_PRIV _Integer_limits<char, CHAR_MIN, CHAR_MAX, -1, true>
+{};
+
+#if !defined (_STLP_NO_SIGNED_BUILTINS)
+_STLP_TEMPLATE_NULL
+class numeric_limits<signed char>
+  : public _STLP_PRIV _Integer_limits<signed char, SCHAR_MIN, SCHAR_MAX, -1, true>
+{};
+#endif
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<unsigned char>
+  : public _STLP_PRIV _Integer_limits<unsigned char, 0, UCHAR_MAX, -1, true>
+{};
+
+#if !(defined (_STLP_NO_WCHAR_T) || defined (_STLP_WCHAR_T_IS_USHORT))
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<wchar_t>
+  : public _STLP_PRIV _Integer_limits<wchar_t, WCHAR_MIN, WCHAR_MAX, -1, true>
+{};
+
+#endif
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<short>
+  : public _STLP_PRIV _Integer_limits<short, SHRT_MIN, SHRT_MAX, -1, true>
+{};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<unsigned short>
+  : public _STLP_PRIV _Integer_limits<unsigned short, 0, USHRT_MAX, -1, true>
+{};
+
+#if defined (__xlC__) && (__xlC__ == 0x500)
+#  undef INT_MIN
+#  define INT_MIN -2147483648
+#endif
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<int>
+  : public _STLP_PRIV _Integer_limits<int, INT_MIN, INT_MAX, -1, true>
+{};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<unsigned int>
+  : public _STLP_PRIV _Integer_limits<unsigned int, 0, UINT_MAX, -1, true>
+{};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<long>
+  : public _STLP_PRIV _Integer_limits<long, LONG_MIN, LONG_MAX, -1, true>
+{};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<unsigned long>
+  : public _STLP_PRIV _Integer_limits<unsigned long, 0, ULONG_MAX, -1, true>
+{};
+
+#if defined (_STLP_LONG_LONG)
+
+#  if defined (_STLP_MSVC) || defined (__BORLANDC__)
+#    define LONGLONG_MAX     0x7fffffffffffffffi64
+#    define LONGLONG_MIN     (-LONGLONG_MAX-1i64)
+#    define ULONGLONG_MAX    0xffffffffffffffffUi64
+#  else
+#    ifndef LONGLONG_MAX
+#      define LONGLONG_MAX   0x7fffffffffffffffLL
+#    endif
+#    ifndef LONGLONG_MIN
+#      define LONGLONG_MIN   (-LONGLONG_MAX-1LL)
+#    endif
+#    ifndef ULONGLONG_MAX
+#      define ULONGLONG_MAX  0xffffffffffffffffULL
+#    endif
+#  endif
+
+#  if !defined (__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ <= 96) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 3)
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<_STLP_LONG_LONG>
+  : public _STLP_PRIV _Integer_limits<_STLP_LONG_LONG, LONGLONG_MIN, LONGLONG_MAX, -1, true>
+{};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<unsigned _STLP_LONG_LONG>
+  : public _STLP_PRIV _Integer_limits<unsigned _STLP_LONG_LONG, 0, ULONGLONG_MAX, -1, true>
+{};
+#  else /* gcc 2.97 (after 2000-11-01), 2.98, 3.0 */
+/*
+ newest gcc has new mangling scheme, that has problem
+ with generating name [instantiated] of template specialization like
+ _Integer_limits<_STLP_LONG_LONG, LONGLONG_MIN, LONGLONG_MAX, -1, true>
+                                  ~~~~~~~~~~~~  ~~~~~~~~~~~~
+ Below is code that solve this problem.
+   - ptr
+ */
+_STLP_TEMPLATE_NULL
+class numeric_limits<_STLP_LONG_LONG>
+  : public _STLP_PRIV _Numeric_limits_base<_STLP_LONG_LONG> {
+public:
+
+  static _STLP_LONG_LONG (_STLP_CALL min) () _STLP_NOTHROW { return LONGLONG_MIN; }
+  static _STLP_LONG_LONG (_STLP_CALL max) () _STLP_NOTHROW { return LONGLONG_MAX; }
+
+  _STLP_STATIC_CONSTANT(int, digits = ((int)((sizeof(_STLP_LONG_LONG) * (CHAR_BIT))) - 1));
+  _STLP_STATIC_CONSTANT(int, digits10 = (digits * 301UL) / 1000);
+  _STLP_STATIC_CONSTANT(int, radix = 2);
+  _STLP_STATIC_CONSTANT(bool, is_specialized = true);
+  _STLP_STATIC_CONSTANT(bool, is_signed = true);
+  _STLP_STATIC_CONSTANT(bool, is_integer = true);
+  _STLP_STATIC_CONSTANT(bool, is_exact = true);
+  _STLP_STATIC_CONSTANT(bool, is_bounded = true);
+  _STLP_STATIC_CONSTANT(bool, is_modulo = true);
+};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<unsigned _STLP_LONG_LONG>
+  : public _STLP_PRIV _Numeric_limits_base<unsigned _STLP_LONG_LONG> {
+public:
+
+  static unsigned _STLP_LONG_LONG (_STLP_CALL min) () _STLP_NOTHROW { return 0ULL; }
+  static unsigned _STLP_LONG_LONG (_STLP_CALL max) () _STLP_NOTHROW { return ULONGLONG_MAX; }
+
+  _STLP_STATIC_CONSTANT(int, digits = ((int)((sizeof(unsigned _STLP_LONG_LONG) * (CHAR_BIT)))));
+  _STLP_STATIC_CONSTANT(int, digits10 = (digits * 301UL) / 1000);
+  _STLP_STATIC_CONSTANT(int, radix = 2);
+  _STLP_STATIC_CONSTANT(bool, is_specialized = true);
+  _STLP_STATIC_CONSTANT(bool, is_signed = false);
+  _STLP_STATIC_CONSTANT(bool, is_integer = true);
+  _STLP_STATIC_CONSTANT(bool, is_exact = true);
+  _STLP_STATIC_CONSTANT(bool, is_bounded = true);
+  _STLP_STATIC_CONSTANT(bool, is_modulo = true);
+};
+
+#  endif /* __GNUC__ > 2000-11-01 */
+
+#endif /* _STLP_LONG_LONG */
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// Specializations for all built-in floating-point types.
+template <class __dummy>
+class _LimG {
+public:
+  static float _STLP_CALL get_F_inf();
+  static float _STLP_CALL get_F_qNaN();
+  static float _STLP_CALL get_F_sNaN();
+  static float _STLP_CALL get_F_denormMin();
+  static double _STLP_CALL get_D_inf();
+  static double _STLP_CALL get_D_qNaN();
+  static double _STLP_CALL get_D_sNaN();
+  static double _STLP_CALL get_D_denormMin();
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+  static long double _STLP_CALL get_LD_inf();
+  static long double _STLP_CALL get_LD_qNaN();
+  static long double _STLP_CALL get_LD_sNaN();
+  static long double _STLP_CALL get_LD_denormMin();
+#endif
+};
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS _LimG<bool>;
+#endif
+
+#if defined (__GNUC__)
+#  if defined (__FLT_DENORM_MIN__)
+#    define _STLP_FLT_DENORM_MIN __FLT_DENORM_MIN__
+#  else
+#    define _STLP_FLT_DENORM_STYLE denorm_absent
+#  endif
+#  if defined (__DBL_DENORM_MIN__)
+#    define _STLP_DBL_DENORM_MIN __DBL_DENORM_MIN__
+#  else
+#    define _STLP_DBL_DENORM_STYLE denorm_absent
+#  endif
+#  if defined (__LDBL_DENORM_MIN__)
+#    define _STLP_LDBL_DENORM_MIN __LDBL_DENORM_MIN__
+#  else
+#    define _STLP_LDBL_DENORM_STYLE denorm_absent
+#  endif
+#endif
+
+/* If compiler do not expose thanks to some macro its status regarding
+ * denormalized floating point numbers, we consider that denormalization
+ * is present. Unit tests will tell us if compiler do not support them. */
+#if !defined (_STLP_FLT_DENORM_STYLE)
+#  define _STLP_FLT_DENORM_STYLE denorm_present
+#endif
+
+#if !defined (_STLP_DBL_DENORM_STYLE)
+#  define _STLP_DBL_DENORM_STYLE denorm_present
+#endif
+
+#if !defined (_STLP_LDBL_DENORM_STYLE)
+#  define _STLP_LDBL_DENORM_STYLE denorm_present
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<float>
+  : public _STLP_PRIV _Floating_limits<float,
+                                       FLT_MANT_DIG,   // Binary digits of precision
+                                       FLT_DIG,        // Decimal digits of precision
+                                       FLT_MIN_EXP,    // Minimum exponent
+                                       FLT_MAX_EXP,    // Maximum exponent
+                                       FLT_MIN_10_EXP, // Minimum base 10 exponent
+                                       FLT_MAX_10_EXP, // Maximum base 10 exponent
+                                       true,
+                                       _STLP_FLT_DENORM_STYLE,
+                                       round_to_nearest> {
+public:
+  static float (_STLP_CALL min) () _STLP_NOTHROW { return FLT_MIN; }
+  static float _STLP_CALL denorm_min() _STLP_NOTHROW
+#if defined (_STLP_FLT_DENORM_MIN)
+  { return _STLP_FLT_DENORM_MIN; }
+#else
+  { return _STLP_FLT_DENORM_STYLE ? _STLP_PRIV _LimG<bool>::get_F_denormMin() : FLT_MIN; }
+#endif
+  static float (_STLP_CALL max) () _STLP_NOTHROW { return FLT_MAX; }
+  static float _STLP_CALL epsilon() _STLP_NOTHROW { return FLT_EPSILON; }
+  static float _STLP_CALL round_error() _STLP_NOTHROW { return 0.5f; } // Units: ulps.
+  static  float _STLP_CALL infinity() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_F_inf(); }
+  static  float _STLP_CALL quiet_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_F_qNaN(); }
+  static  float _STLP_CALL signaling_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_F_sNaN(); }
+};
+
+#undef _STLP_FLT_DENORM_MIN
+#undef _STLP_FLT_DNORM_STYLE
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<double>
+  : public _STLP_PRIV _Floating_limits<double,
+                                       DBL_MANT_DIG,   // Binary digits of precision
+                                       DBL_DIG,        // Decimal digits of precision
+                                       DBL_MIN_EXP,    // Minimum exponent
+                                       DBL_MAX_EXP,    // Maximum exponent
+                                       DBL_MIN_10_EXP, // Minimum base 10 exponent
+                                       DBL_MAX_10_EXP, // Maximum base 10 exponent
+                                       true,
+                                       _STLP_DBL_DENORM_STYLE,
+                                       round_to_nearest> {
+public:
+  static double (_STLP_CALL min)() _STLP_NOTHROW { return DBL_MIN; }
+  static double _STLP_CALL denorm_min() _STLP_NOTHROW
+#if defined (_STLP_DBL_DENORM_MIN)
+  { return _STLP_DBL_DENORM_MIN; }
+#else
+  { return _STLP_DBL_DENORM_STYLE ? _STLP_PRIV _LimG<bool>::get_D_denormMin() : DBL_MIN; }
+#endif
+  static double (_STLP_CALL max)() _STLP_NOTHROW { return DBL_MAX; }
+  static double _STLP_CALL epsilon() _STLP_NOTHROW { return DBL_EPSILON; }
+  static double _STLP_CALL round_error() _STLP_NOTHROW { return 0.5; } // Units: ulps.
+  static  double _STLP_CALL infinity() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_D_inf(); }
+  static  double _STLP_CALL quiet_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_D_qNaN(); }
+  static  double _STLP_CALL signaling_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_D_sNaN(); }
+};
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<long double>
+  : public _STLP_PRIV _Floating_limits<long double,
+                                       LDBL_MANT_DIG,  // Binary digits of precision
+                                       LDBL_DIG,       // Decimal digits of precision
+                                       LDBL_MIN_EXP,   // Minimum exponent
+                                       LDBL_MAX_EXP,   // Maximum exponent
+                                       LDBL_MIN_10_EXP,// Minimum base 10 exponent
+                                       LDBL_MAX_10_EXP,// Maximum base 10 exponent
+                                       false,          // do not conform to iec559
+                                       _STLP_LDBL_DENORM_STYLE,
+                                       round_to_nearest> {
+public:
+  static long double (_STLP_CALL min) () _STLP_NOTHROW { return LDBL_MIN; }
+  static long double _STLP_CALL denorm_min() _STLP_NOTHROW
+#if defined (_STLP_LDBL_DENORM_MIN)
+  { return _STLP_LDBL_DENORM_MIN; }
+#else
+  { return _STLP_LDBL_DENORM_STYLE ? _STLP_PRIV _LimG<bool>::get_LD_denormMin() : LDBL_MIN; }
+#endif
+  _STLP_STATIC_CONSTANT(bool, is_iec559 = false);
+  static long double (_STLP_CALL max) () _STLP_NOTHROW { return LDBL_MAX; }
+  static long double _STLP_CALL epsilon() _STLP_NOTHROW { return LDBL_EPSILON; }
+  static long double _STLP_CALL round_error() _STLP_NOTHROW { return 0.5l; }
+  static long double _STLP_CALL infinity() _STLP_NOTHROW
+  //For MSVC, long double is nothing more than an alias for double.
+#if !defined (_STLP_MSVC)
+  { return _STLP_PRIV _LimG<bool>::get_LD_inf(); }
+#else
+  { return _STLP_PRIV _LimG<bool>::get_D_inf(); }
+#endif
+  static long double _STLP_CALL quiet_NaN() _STLP_NOTHROW
+#if !defined (_STLP_MSVC)
+  { return _STLP_PRIV _LimG<bool>::get_LD_qNaN(); }
+#else
+  { return _STLP_PRIV _LimG<bool>::get_D_qNaN(); }
+#endif
+  static long double _STLP_CALL signaling_NaN() _STLP_NOTHROW
+#if !defined (_STLP_MSVC)
+  { return _STLP_PRIV _LimG<bool>::get_LD_sNaN(); }
+#else
+  { return _STLP_PRIV _LimG<bool>::get_D_sNaN(); }
+#endif
+};
+
+#endif
+
+// We write special values (Inf and NaN) as bit patterns and
+// cast the the appropriate floating-point types.
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+#  include <stl/_limits.c>
+#endif
+
+#endif
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_mbstate_t.h b/stlport/stlport/stl/_mbstate_t.h
new file mode 100644
index 0000000..e6a3e75
--- /dev/null
+++ b/stlport/stlport/stl/_mbstate_t.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_MBSTATE_T
+#define _STLP_INTERNAL_MBSTATE_T
+
+#if (defined (__OpenBSD__) || defined (__FreeBSD__) || defined (__hpux)) && defined (__GNUC__) && !defined (_GLIBCPP_HAVE_MBSTATE_T)
+#  define _STLP_CPP_MBSTATE_T /* mbstate_t defined in native <cwchar>, so not defined in C! */
+#endif
+
+#if defined (_STLP_NO_NATIVE_MBSTATE_T) || defined (_STLP_CPP_MBSTATE_T) && !defined (_MBSTATE_T)
+#  define _STLP_USE_OWN_MBSTATE_T
+#  define _MBSTATE_T
+#endif
+
+#if defined (_STLP_USE_OWN_MBSTATE_T)
+#  if !defined (_STLP_CPP_MBSTATE_T) || !defined (__cplusplus) || !defined (_STLP_USE_NEW_C_HEADERS)
+typedef int mbstate_t;
+#  endif
+
+#  if !defined (_STLP_CPP_MBSTATE_T) && defined (__cplusplus) && defined (_STLP_USE_NAMESPACES)
+_STLP_BEGIN_NAMESPACE
+using ::mbstate_t;
+_STLP_END_NAMESPACE
+#  endif
+
+#endif /* _STLP_USE_OWN_MBSTATE_T */
+
+#endif /* _STLP_INTERNAL_MBSTATE_T */
diff --git a/stlport/stlport/stl/_queue.h b/stlport/stlport/stl/_queue.h
new file mode 100644
index 0000000..5f3763c
--- /dev/null
+++ b/stlport/stlport/stl/_queue.h
@@ -0,0 +1,268 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_QUEUE_H
+#define _STLP_INTERNAL_QUEUE_H
+
+#ifndef _STLP_INTERNAL_DEQUE_H
+#  include <stl/_deque.h>
+#endif
+
+#ifndef _STLP_INTERNAL_VECTOR_H
+# include <stl/_vector.h>
+#endif
+
+#ifndef _STLP_INTERNAL_HEAP_H
+#  include <stl/_heap.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+#  include <stl/_function_base.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+# if ! defined ( _STLP_LIMITED_DEFAULT_TEMPLATES )
+template <class _Tp, class _Sequence = deque<_Tp> >
+# elif defined ( _STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS )
+#  define _STLP_QUEUE_ARGS _Tp
+template <class _Tp>
+# else
+template <class _Tp, class _Sequence>
+# endif
+class queue
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+#  if defined (_STLP_QUEUE_ARGS)
+            : public __stlport_class<queue<_Tp> >
+#  else
+            : public __stlport_class<queue<_Tp, _Sequence> >
+#  endif
+#endif
+{
+# if defined ( _STLP_QUEUE_ARGS )
+  typedef deque<_Tp> _Sequence;
+  typedef queue<_Tp> _Self;
+# else
+  typedef queue<_Tp, _Sequence> _Self;
+# endif
+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:
+  //c is a Standard name (23.2.3.1), do no make it STLport naming convention compliant.
+  _Sequence c;
+public:
+  queue() : c() {}
+  explicit queue(const _Sequence& __c) : c(__c) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+  queue(__move_source<_Self> src)
+    : c(_STLP_PRIV _AsMoveSource(src.get().c)) {}
+#endif
+
+  bool empty() const { return c.empty(); }
+  size_type size() const { return c.size(); }
+  reference front() { return c.front(); }
+  const_reference front() const { return c.front(); }
+  reference back() { return c.back(); }
+  const_reference back() const { return c.back(); }
+  void push(const value_type& __x) { c.push_back(__x); }
+  void pop() { c.pop_front(); }
+  const _Sequence& _Get_s() const { return c; }
+
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+  void _M_swap_workaround(_Self& __x) {
+    _Sequence __tmp = c;
+    c = __x.c;
+    __x.c = __tmp;
+  }
+#endif
+};
+
+#ifndef _STLP_QUEUE_ARGS
+#  define _STLP_QUEUE_ARGS _Tp, _Sequence
+#  define _STLP_QUEUE_HEADER_ARGS class _Tp, class _Sequence
+#else
+#  define _STLP_QUEUE_HEADER_ARGS class _Tp
+#endif
+
+template < _STLP_QUEUE_HEADER_ARGS >
+inline bool _STLP_CALL
+operator==(const queue<_STLP_QUEUE_ARGS >& __x, const queue<_STLP_QUEUE_ARGS >& __y) {
+  return __x._Get_s() == __y._Get_s();
+}
+
+template < _STLP_QUEUE_HEADER_ARGS >
+inline bool _STLP_CALL
+operator<(const queue<_STLP_QUEUE_ARGS >& __x, const queue<_STLP_QUEUE_ARGS >& __y) {
+  return __x._Get_s() < __y._Get_s();
+}
+
+_STLP_RELOPS_OPERATORS( template < _STLP_QUEUE_HEADER_ARGS >, queue<_STLP_QUEUE_ARGS > )
+
+# if !(defined ( _STLP_LIMITED_DEFAULT_TEMPLATES ) || defined ( _STLP_TEMPLATE_PARAM_SUBTYPE_BUG ))
+template <class _Tp, class _Sequence = vector<_Tp>,
+          class _Compare = less<_STLP_HEADER_TYPENAME _Sequence::value_type> >
+# elif defined ( _STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS )
+template <class _Tp>
+# else
+template <class _Tp, class _Sequence, class _Compare>
+# endif
+class priority_queue
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+#  if defined (_STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS)
+            : public __stlport_class<priority_queue<_Tp> >
+#  else
+            : public __stlport_class<priority_queue<_Tp, _Sequence> >
+#  endif
+#endif
+{
+# ifdef _STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS
+  typedef vector<_Tp> _Sequence;
+  typedef less< typename vector<_Tp>::value_type> _Compare;
+  typedef priority_queue<_Tp> _Self;
+# else
+  typedef priority_queue<_Tp, _Sequence, _Compare> _Self;
+# endif
+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:
+  //c is a Standard name (23.2.3.2), do no make it STLport naming convention compliant.
+  _Sequence c;
+  _Compare comp;
+public:
+  priority_queue() : c() {}
+  explicit priority_queue(const _Compare& __x) :  c(), comp(__x) {}
+  priority_queue(const _Compare& __x, const _Sequence& __s)
+    : c(__s), comp(__x)
+    { make_heap(c.begin(), c.end(), comp); }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+  priority_queue(__move_source<_Self> src)
+    : c(_STLP_PRIV _AsMoveSource(src.get().c)),
+      comp(_STLP_PRIV _AsMoveSource(src.get().comp)) {}
+#endif
+
+#ifdef _STLP_MEMBER_TEMPLATES
+  template <class _InputIterator>
+  priority_queue(_InputIterator __first, _InputIterator __last)
+    : c(__first, __last) { make_heap(c.begin(), c.end(), comp); }
+
+  template <class _InputIterator>
+  priority_queue(_InputIterator __first,
+                 _InputIterator __last, const _Compare& __x)
+    : c(__first, __last), comp(__x)
+    { make_heap(c.begin(), c.end(), comp); }
+
+  template <class _InputIterator>
+  priority_queue(_InputIterator __first, _InputIterator __last,
+                 const _Compare& __x, const _Sequence& __s)
+  : c(__s), comp(__x)
+  {
+    c.insert(c.end(), __first, __last);
+    make_heap(c.begin(), c.end(), comp);
+  }
+
+#else /* _STLP_MEMBER_TEMPLATES */
+  priority_queue(const value_type* __first, const value_type* __last)
+    : c(__first, __last) { make_heap(c.begin(), c.end(), comp); }
+
+  priority_queue(const value_type* __first, const value_type* __last,
+                 const _Compare& __x)
+    : c(__first, __last), comp(__x)
+    { make_heap(c.begin(), c.end(), comp); }
+
+  priority_queue(const value_type* __first, const value_type* __last,
+                 const _Compare& __x, const _Sequence& __c)
+    : c(__c), comp(__x)
+  {
+    c.insert(c.end(), __first, __last);
+    make_heap(c.begin(), c.end(), comp);
+  }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+  bool empty() const { return c.empty(); }
+  size_type size() const { return c.size(); }
+  const_reference top() const { return c.front(); }
+  void push(const value_type& __x) {
+    _STLP_TRY {
+      c.push_back(__x);
+      push_heap(c.begin(), c.end(), comp);
+    }
+    _STLP_UNWIND(c.clear())
+  }
+  void pop() {
+    _STLP_TRY {
+      pop_heap(c.begin(), c.end(), comp);
+      c.pop_back();
+    }
+    _STLP_UNWIND(c.clear())
+  }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+  void _M_swap_workaround(_Self& __x) {
+    _Sequence __tmp = c;
+    c = __x.c;
+    __x.c = __tmp;
+  }
+#endif
+};
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Tp, class _Sequence>
+struct __move_traits<queue<_Tp, _Sequence> > :
+  _STLP_PRIV __move_traits_aux<_Sequence>
+{};
+
+template <class _Tp, class _Sequence, class _Compare>
+struct __move_traits<priority_queue<_Tp, _Sequence, _Compare> > :
+  _STLP_PRIV __move_traits_aux2<_Sequence, _Compare>
+{};
+#endif
+
+_STLP_END_NAMESPACE
+
+#undef _STLP_QUEUE_ARGS
+#undef _STLP_QUEUE_HEADER_ARGS
+#undef comp
+
+#endif /* _STLP_INTERNAL_QUEUE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_raw_storage_iter.h b/stlport/stlport/stl/_raw_storage_iter.h
new file mode 100644
index 0000000..6e4bc2e
--- /dev/null
+++ b/stlport/stlport/stl/_raw_storage_iter.h
@@ -0,0 +1,80 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_RAW_STORAGE_ITERATOR_H
+#define _STLP_INTERNAL_RAW_STORAGE_ITERATOR_H
+
+#ifndef _STLP_INTERNAL_ITERATOR_BASE_H
+#  include <stl/_iterator_base.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _ForwardIterator, class _Tp>
+class raw_storage_iterator
+      : public iterator<output_iterator_tag,void,void,void,void>
+{
+protected:
+  _ForwardIterator _M_iter;
+public:
+  typedef output_iterator_tag iterator_category;
+# ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
+  typedef void                value_type;
+  typedef void                difference_type;
+  typedef void                pointer;
+  typedef void                reference;
+# endif
+  explicit raw_storage_iterator(_ForwardIterator __x) : _M_iter(__x) {}
+  raw_storage_iterator<_ForwardIterator, _Tp>& operator*() { return *this; }
+  raw_storage_iterator<_ForwardIterator, _Tp>& operator=(const _Tp& __element) {
+    _Param_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;
+  }
+};
+
+# ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
+template <class _ForwardIterator, class _Tp>
+inline output_iterator_tag iterator_category(const raw_storage_iterator<_ForwardIterator, _Tp>&) { return output_iterator_tag(); }
+#endif
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_RAW_STORAGE_ITERATOR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_relops_hash_cont.h b/stlport/stlport/stl/_relops_hash_cont.h
new file mode 100644
index 0000000..421c805
--- /dev/null
+++ b/stlport/stlport/stl/_relops_hash_cont.h
@@ -0,0 +1,13 @@
+/* This is an implementation file which is intended to be included
+ * multiple times with different _STLP_TEMPLATE_CONTAINER settings.
+ */
+
+#if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+
+_STLP_TEMPLATE_HEADER
+inline void _STLP_CALL
+swap(_STLP_TEMPLATE_CONTAINER& __hm1, _STLP_TEMPLATE_CONTAINER& __hm2) {
+  __hm1.swap(__hm2);
+}
+
+#endif /* _STLP_FUNCTION_TMPL_PARTIAL_ORDER */
diff --git a/stlport/stlport/stl/_slist.c b/stlport/stlport/stl/_slist.c
new file mode 100644
index 0000000..ba158d0
--- /dev/null
+++ b/stlport/stlport/stl/_slist.c
@@ -0,0 +1,231 @@
+/*
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_SLIST_C
+#define _STLP_SLIST_C
+
+#ifndef _STLP_INTERNAL_SLIST_H
+#  include <stl/_slist.h>
+#endif
+
+#ifndef _STLP_CARRAY_H
+#  include <stl/_carray.h>
+#endif
+
+#ifndef _STLP_RANGE_ERRORS_H
+#  include <stl/_range_errors.h>
+#endif
+
+#if defined (_STLP_NESTED_TYPE_PARAM_BUG)
+#  define size_type size_t
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+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_base* __cur = __before_first->_M_next;
+  while (__cur != __last_node) {
+    _Node* __tmp = __STATIC_CAST(_Node*, __cur);
+    __cur = __cur->_M_next;
+    _STLP_STD::_Destroy(&__tmp->_M_data);
+    _M_head.deallocate(__tmp,1);
+  }
+  __before_first->_M_next = __last_node;
+  return __last_node;
+}
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+#  define slist _STLP_PTR_IMPL_NAME(slist)
+#elif defined (_STLP_DEBUG)
+#  define slist _STLP_NON_DBG_NAME(slist)
+#else
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+/* When building STLport lib Digital Mars Compiler complains on the _M_data assignment
+ * problem which would be perfertly right if we were using it. Hiding it during build
+ * fix this issue.
+ */
+template <class _Tp, class _Alloc>
+slist<_Tp,_Alloc>& slist<_Tp,_Alloc>::operator=(const slist<_Tp,_Alloc>& __x) {
+  if (&__x != this) {
+    _Node_base* __p1 = &this->_M_head._M_data;
+    _Node_base* __n1 = this->_M_head._M_data._M_next;
+    const _Node_base* __n2 = __x._M_head._M_data._M_next;
+    while (__n1 && __n2) {
+      __STATIC_CAST(_Node*, __n1)->_M_data = __STATIC_CAST(const _Node*, __n2)->_M_data;
+      __p1 = __n1;
+      __n1 = __n1->_M_next;
+      __n2 = __n2->_M_next;
+    }
+    if (__n2 == 0)
+      this->_M_erase_after(__p1, 0);
+    else
+      _M_insert_after_range(__p1, const_iterator(__CONST_CAST(_Node_base*, __n2)),
+                                  const_iterator(0));
+  }
+  return *this;
+}
+
+template <class _Tp, class _Alloc>
+void slist<_Tp, _Alloc>::_M_fill_assign(size_type __n, const _Tp& __val) {
+  _Node_base* __prev = &this->_M_head._M_data;
+  _Node_base* __node = this->_M_head._M_data._M_next;
+  for ( ; __node != 0 && __n > 0 ; --__n) {
+    __STATIC_CAST(_Node*, __node)->_M_data = __val;
+    __prev = __node;
+    __node = __node->_M_next;
+  }
+  if (__n > 0)
+    _M_insert_after_fill(__prev, __n, __val);
+  else
+    this->_M_erase_after(__prev, 0);
+}
+
+template <class _Tp, class _Alloc>
+void slist<_Tp,_Alloc>::resize(size_type __len, const _Tp& __x) {
+  _Node_base* __cur = &this->_M_head._M_data;
+  while (__cur->_M_next != 0 && __len > 0) {
+    --__len;
+    __cur = __cur->_M_next;
+  }
+  if (__cur->_M_next)
+    this->_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 = &this->_M_head._M_data;
+  while (__cur && __cur->_M_next) {
+    if (__STATIC_CAST(_Node*, __cur->_M_next)->_M_data == __val)
+      this->_M_erase_after(__cur);
+    else
+      __cur = __cur->_M_next;
+  }
+}
+
+#if !defined (slist)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+template <class _Tp, class _Alloc, class _BinaryPredicate>
+void _Slist_unique(slist<_Tp, _Alloc>& __that, _BinaryPredicate __pred) {
+  typedef _Slist_node<_Tp> _Node;
+  typename slist<_Tp, _Alloc>::iterator __ite(__that.begin());
+  if (__ite != __that.end()) {
+    while (__ite._M_node->_M_next) {
+      if (__pred(*__ite, __STATIC_CAST(_Node*, __ite._M_node->_M_next)->_M_data))
+        __that.erase_after(__ite);
+      else
+        ++__ite;
+    }
+  }
+}
+
+template <class _Tp, class _Alloc, class _StrictWeakOrdering>
+void _Slist_merge(slist<_Tp, _Alloc>& __that, slist<_Tp, _Alloc>& __x,
+                  _StrictWeakOrdering __comp) {
+  typedef _Slist_node<_Tp> _Node;
+  typedef _STLP_PRIV _Slist_node_base _Node_base;
+  if (__that.get_allocator() == __x.get_allocator()) {
+    typename slist<_Tp, _Alloc>::iterator __ite(__that.before_begin());
+    while (__ite._M_node->_M_next && !__x.empty()) {
+      if (__comp(__x.front(), __STATIC_CAST(_Node*, __ite._M_node->_M_next)->_M_data)) {
+        _STLP_VERBOSE_ASSERT(!__comp(__STATIC_CAST(_Node*, __ite._M_node->_M_next)->_M_data, __x.front()),
+                             _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+        __that.splice_after(__ite, __x, __x.before_begin());
+      }
+      ++__ite;
+    }
+    if (!__x.empty()) {
+      __that.splice_after(__ite, __x);
+    }
+  }
+  else {
+    typename slist<_Tp, _Alloc>::iterator __i1(__that.before_begin()), __i2(__x.begin());
+    while (__i1._M_node->_M_next && __i2._M_node) {
+      if (__comp(__STATIC_CAST(_Node*, __i1._M_node->_M_next)->_M_data, *__i2)) {
+        _STLP_VERBOSE_ASSERT(!__comp(*__i2, __STATIC_CAST(_Node*, __i1._M_node->_M_next)->_M_data),
+                             _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+        ++__i1;
+      }
+      else {
+        __i1 = __that.insert_after(__i1, *(__i2++));
+      }
+    }
+    __that.insert_after(__i1, __i2, __x.end());
+    __x.clear();
+  }
+}
+
+template <class _Tp, class _Alloc, class _StrictWeakOrdering>
+void _Slist_sort(slist<_Tp, _Alloc>& __that, _StrictWeakOrdering __comp) {
+  if (!__that.begin()._M_node || !__that.begin()._M_node->_M_next)
+    return;
+
+  slist<_Tp, _Alloc> __carry(__that.get_allocator());
+  const int NB = 64;
+  _STLP_PRIV _CArray<slist<_Tp, _Alloc>, NB> __counter(__carry);
+  int __fill = 0;
+  while (!__that.empty()) {
+    __carry.splice_after(__carry.before_begin(), __that, __that.before_begin());
+    int __i = 0;
+    while (__i < __fill && !__counter[__i].empty()) {
+      _STLP_PRIV _Slist_merge(__counter[__i], __carry, __comp);
+      __carry.swap(__counter[__i]);
+      ++__i;
+    }
+    __carry.swap(__counter[__i]);
+    if (__i == __fill) {
+      ++__fill;
+      if (__fill >= NB) {
+        //Looks like the slist has too many elements to be sorted with this algorithm:
+        __stl_throw_overflow_error("slist::sort");
+      }
+    }
+  }
+
+  for (int __i = 1; __i < __fill; ++__i)
+    _STLP_PRIV _Slist_merge(__counter[__i], __counter[__i - 1], __comp);
+  __that.swap(__counter[__fill-1]);
+}
+
+#if defined (slist)
+#  undef slist
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#if defined (_STLP_NESTED_TYPE_PARAM_BUG)
+#  undef size_type
+#endif
+
+#endif /*  _STLP_SLIST_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_slist.h b/stlport/stlport/stl/_slist.h
new file mode 100644
index 0000000..924daa4
--- /dev/null
+++ b/stlport/stlport/stl/_slist.h
@@ -0,0 +1,914 @@
+/*
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_SLIST_H
+#define _STLP_INTERNAL_SLIST_H
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+#  include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+#  include <stl/_alloc.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_H
+#  include <stl/_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CONSTRUCT_H
+#  include <stl/_construct.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+#  include <stl/_function_base.h>
+#endif
+
+#ifndef _STLP_INTERNAL_SLIST_BASE_H
+#  include <stl/_slist_base.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp>
+class _Slist_node : public _Slist_node_base {
+public:
+  _Tp _M_data;
+  __TRIVIAL_STUFF(_Slist_node)
+};
+
+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;
+  }
+};
+
+template <class _Tp, class _Traits>
+class _Slist_iterator : public _Slist_iterator_base {
+public:
+  typedef typename _Traits::value_type value_type;
+  typedef typename _Traits::pointer    pointer;
+  typedef typename _Traits::reference  reference;
+  typedef forward_iterator_tag iterator_category;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+
+  typedef _Slist_iterator<_Tp, _Traits>         _Self;
+  typedef typename _Traits::_NonConstTraits     _NonConstTraits;
+  typedef _Slist_iterator<_Tp, _NonConstTraits> iterator;
+  typedef typename _Traits::_ConstTraits        _ConstTraits;
+  typedef _Slist_iterator<_Tp, _ConstTraits>    const_iterator;
+
+  typedef _Slist_node<value_type> _Node;
+
+  explicit _Slist_iterator(_Slist_node_base *__x) : _Slist_iterator_base(__x) {}
+  _Slist_iterator() : _Slist_iterator_base(0) {}
+  //copy constructor for iterator and constructor from iterator for const_iterator
+  _Slist_iterator(const iterator& __x) : _Slist_iterator_base(__x._M_node) {}
+
+  reference operator*() const { return __STATIC_CAST(_Node*, this->_M_node)->_M_data; }
+
+  _STLP_DEFINE_ARROW_OPERATOR
+
+  _Self& operator++() {
+    _M_incr();
+    return *this;
+  }
+  _Self operator++(int) {
+    _Self __tmp = *this;
+    _M_incr();
+    return __tmp;
+  }
+
+  bool operator==(const_iterator __y ) const {
+    return this->_M_node == __y._M_node;
+  }
+  bool operator!=(const_iterator __y ) const {
+    return this->_M_node != __y._M_node;
+  }
+};
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+_STLP_MOVE_TO_STD_NAMESPACE
+template <class _Tp, class _Traits>
+struct __type_traits<_STLP_PRIV _Slist_iterator<_Tp, _Traits> > {
+  typedef __false_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 __false_type   is_POD_type;
+};
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+#if defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)
+_STLP_MOVE_TO_STD_NAMESPACE
+template <class _Tp, class _Traits>
+inline _Tp* _STLP_CALL value_type(const _STLP_PRIV _Slist_iterator<_Tp, _Traits>&) { return __STATIC_CAST(_Tp*, 0); }
+inline ptrdiff_t* _STLP_CALL distance_type(const _STLP_PRIV _Slist_iterator_base&) { return 0; }
+inline forward_iterator_tag _STLP_CALL iterator_category(const _STLP_PRIV _Slist_iterator_base&) { return forward_iterator_tag(); }
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif /* OLD_QUERIES */
+
+// Base class that encapsulates details of allocators and simplifies EH
+template <class _Tp, class _Alloc>
+class _Slist_base {
+protected:
+  typedef _Slist_node<_Tp> _Node;
+  typedef typename _Alloc_traits<_Node,_Alloc>::allocator_type _M_node_allocator_type;
+  typedef _Slist_base<_Tp, _Alloc> _Self;
+
+public:
+  typedef _STLP_alloc_proxy<_Slist_node_base, _Node, _M_node_allocator_type> _AllocProxy;
+
+  _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
+  typedef _Alloc allocator_type;
+
+  _Slist_base(const allocator_type& __a) :
+    _M_head(_STLP_CONVERT_ALLOCATOR(__a, _Node), _Slist_node_base() )
+  { _M_head._M_data._M_next = 0; }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+  _Slist_base(__move_source<_Self> src) :
+    _M_head(__move_source<_AllocProxy>(src.get()._M_head))
+  { src.get()._M_head._M_data._M_next = 0; }
+#endif
+
+  ~_Slist_base() { _M_erase_after(&_M_head._M_data, 0); }
+
+protected:
+  _Slist_node_base* _M_erase_after(_Slist_node_base* __pos) {
+    _Node* __next = __STATIC_CAST(_Node*, __pos->_M_next);
+    _Slist_node_base* __next_next = __next->_M_next;
+    __pos->_M_next = __next_next;
+    _STLP_STD::_Destroy(&__next->_M_data);
+    _M_head.deallocate(__next,1);
+    return __next_next;
+  }
+  _Slist_node_base* _M_erase_after(_Slist_node_base*, _Slist_node_base*);
+
+public:
+  allocator_type get_allocator() const
+  { return _STLP_CONVERT_ALLOCATOR((const _M_node_allocator_type&)_M_head, _Tp); }
+  _AllocProxy _M_head;
+};
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+#  define slist _STLP_PTR_IMPL_NAME(slist)
+#elif defined (_STLP_DEBUG)
+#  define slist _STLP_NON_DBG_NAME(slist)
+#else
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+template <class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Tp>) >
+class slist;
+
+#if !defined (slist)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+// helper functions to reduce code duplication
+template <class _Tp, class _Alloc, class _BinaryPredicate>
+void _Slist_unique(slist<_Tp, _Alloc>& __that, _BinaryPredicate __binary_pred);
+
+template <class _Tp, class _Alloc, class _StrictWeakOrdering>
+void _Slist_merge(slist<_Tp, _Alloc>& __that, slist<_Tp, _Alloc>& __x,
+                  _StrictWeakOrdering __comp);
+
+template <class _Tp, class _Alloc, class _StrictWeakOrdering>
+void _Slist_sort(slist<_Tp, _Alloc>& __that, _StrictWeakOrdering __comp);
+
+#if !defined (slist)
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+template <class _Tp, class _Alloc>
+class slist : protected _STLP_PRIV _Slist_base<_Tp,_Alloc>
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (slist)
+            , public __stlport_class<slist<_Tp, _Alloc> >
+#endif
+{
+private:
+  typedef _STLP_PRIV _Slist_base<_Tp,_Alloc> _Base;
+  typedef slist<_Tp,_Alloc> _Self;
+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 forward_iterator_tag _Iterator_category;
+
+  typedef _STLP_PRIV _Slist_iterator<_Tp, _Nonconst_traits<_Tp> > iterator;
+  typedef _STLP_PRIV _Slist_iterator<_Tp, _Const_traits<_Tp> >    const_iterator;
+
+  _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
+  typedef typename _Base::allocator_type allocator_type;
+
+private:
+  typedef _STLP_PRIV _Slist_node<_Tp> _Node;
+  typedef _STLP_PRIV _Slist_node_base _Node_base;
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+  _Node* _M_create_node(const value_type& __x = _Tp()) {
+#else
+  _Node* _M_create_node(const value_type& __x) {
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+    _Node* __node = this->_M_head.allocate(1);
+    _STLP_TRY {
+      _Copy_Construct(&__node->_M_data, __x);
+      __node->_M_next = 0;
+    }
+    _STLP_UNWIND(this->_M_head.deallocate(__node, 1))
+    return __node;
+  }
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+  _Node* _M_create_node() {
+    _Node* __node = this->_M_head.allocate(1);
+    _STLP_TRY {
+      _STLP_STD::_Construct(&__node->_M_data);
+      __node->_M_next = 0;
+    }
+    _STLP_UNWIND(this->_M_head.deallocate(__node, 1))
+    return __node;
+  }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+public:
+
+  allocator_type get_allocator() const { return _Base::get_allocator(); }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  explicit slist(const allocator_type& __a = allocator_type())
+#else
+  slist()
+    : _STLP_PRIV _Slist_base<_Tp,_Alloc>(allocator_type()) {}
+  slist(const allocator_type& __a)
+#endif
+    : _STLP_PRIV _Slist_base<_Tp,_Alloc>(__a) {}
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  explicit slist(size_type __n, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(_Tp),
+                 const allocator_type& __a =  allocator_type())
+#else
+  explicit slist(size_type __n)
+    : _STLP_PRIV _Slist_base<_Tp,_Alloc>(allocator_type())
+    { _M_insert_after_fill(&this->_M_head._M_data, __n, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+  slist(size_type __n, const value_type& __x)
+    : _STLP_PRIV _Slist_base<_Tp,_Alloc>(allocator_type())
+    { _M_insert_after_fill(&this->_M_head._M_data, __n, __x); }
+  slist(size_type __n, const value_type& __x, const allocator_type& __a)
+#endif
+    : _STLP_PRIV _Slist_base<_Tp,_Alloc>(__a)
+    { _M_insert_after_fill(&this->_M_head._M_data, __n, __x); }
+
+#if defined (_STLP_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 _STLP_ALLOCATOR_TYPE_DFL)
+    : _STLP_PRIV _Slist_base<_Tp,_Alloc>(__a)
+    { _M_insert_after_range(&this->_M_head._M_data, __first, __last); }
+#  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+  // VC++ needs this crazyness
+  template <class _InputIterator>
+  slist(_InputIterator __first, _InputIterator __last)
+    : _STLP_PRIV _Slist_base<_Tp,_Alloc>(allocator_type())
+    { _M_insert_after_range(&this->_M_head._M_data, __first, __last); }
+# endif
+#else /* _STLP_MEMBER_TEMPLATES */
+  slist(const_iterator __first, const_iterator __last,
+        const allocator_type& __a =  allocator_type() )
+    : _STLP_PRIV _Slist_base<_Tp,_Alloc>(__a)
+    { _M_insert_after_range(&this->_M_head._M_data, __first, __last); }
+  slist(const value_type* __first, const value_type* __last,
+        const allocator_type& __a =  allocator_type())
+    : _STLP_PRIV _Slist_base<_Tp,_Alloc>(__a)
+    { _M_insert_after_range(&this->_M_head._M_data, __first, __last); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+  slist(const _Self& __x)
+    : _STLP_PRIV _Slist_base<_Tp,_Alloc>(__x.get_allocator())
+    { _M_insert_after_range(&this->_M_head._M_data, __x.begin(), __x.end()); }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+  slist(__move_source<_Self> src)
+    : _STLP_PRIV _Slist_base<_Tp, _Alloc>(__move_source<_Base>(src.get())) {}
+#endif
+
+  _Self& operator= (const _Self& __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) { _M_fill_assign(__n, __val); }
+
+private:
+  void _M_fill_assign(size_type __n, const _Tp& __val);
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+public:
+  template <class _InputIterator>
+  void assign(_InputIterator __first, _InputIterator __last) {
+    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+    _M_assign_dispatch(__first, __last, _Integral());
+  }
+
+private:
+  template <class _Integer>
+  void _M_assign_dispatch(_Integer __n, _Integer __val,
+                          const __true_type& /*_IsIntegral*/) {
+    _M_fill_assign((size_type) __n, (_Tp) __val);
+  }
+
+  template <class _InputIter>
+  void _M_assign_dispatch(_InputIter __first, _InputIter __last,
+                          const __false_type& /*_IsIntegral*/) {
+#else
+public:
+  void assign(const_pointer __first, const_pointer __last) {
+    _Node_base* __prev = &this->_M_head._M_data;
+    _Node_base* __node = this->_M_head._M_data._M_next;
+    while (__node != 0 && __first != __last) {
+      __STATIC_CAST(_Node*, __node)->_M_data = *__first;
+      __prev = __node;
+      __node = __node->_M_next;
+      ++__first;
+    }
+    if (__first != __last)
+      _M_insert_after_range(__prev, __first, __last);
+    else
+      this->_M_erase_after(__prev, 0);
+  }
+  void assign(const_iterator __first, const_iterator __last) {
+#endif /* _STLP_MEMBER_TEMPLATES */
+    _Node_base* __prev = &this->_M_head._M_data;
+    _Node_base* __node = this->_M_head._M_data._M_next;
+    while (__node != 0 && __first != __last) {
+      __STATIC_CAST(_Node*, __node)->_M_data = *__first;
+      __prev = __node;
+      __node = __node->_M_next;
+      ++__first;
+    }
+    if (__first != __last)
+      _M_insert_after_range(__prev, __first, __last);
+    else
+      this->_M_erase_after(__prev, 0);
+  }
+
+public:
+
+  // Experimental new feature: before_begin() returns a
+  // non-dereferenceable iterator that, when incremented, yields
+  // begin().  This iterator may be used as the argument to
+  // insert_after, erase_after, etc.  Note that even for an empty
+  // slist, before_begin() is not the same iterator as end().  It
+  // is always necessary to increment before_begin() at least once to
+  // obtain end().
+  iterator before_begin() { return iterator(&this->_M_head._M_data); }
+  const_iterator before_begin() const
+    { return const_iterator(__CONST_CAST(_Node_base*, &this->_M_head._M_data)); }
+
+  iterator begin() { return iterator(this->_M_head._M_data._M_next); }
+  const_iterator begin() const
+    { return const_iterator(this->_M_head._M_data._M_next);}
+
+  iterator end() { return iterator(); }
+  const_iterator end() const { return const_iterator(); }
+
+  size_type size() const
+  { return _STLP_PRIV _Sl_global_inst::size(this->_M_head._M_data._M_next); }
+
+  size_type max_size() const { return size_type(-1); }
+
+  bool empty() const { return this->_M_head._M_data._M_next == 0; }
+
+  void swap(_Self& __x)
+  { this->_M_head.swap(__x._M_head); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+  void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+public:
+  reference front()             { return *begin(); }
+  const_reference front() const { return *begin(); }
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+  void push_front(const value_type& __x = _Tp())   {
+#else
+  void push_front(const value_type& __x)   {
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+    _STLP_PRIV __slist_make_link(&this->_M_head._M_data, _M_create_node(__x));
+  }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+  void push_front() { _STLP_PRIV __slist_make_link(&this->_M_head._M_data, _M_create_node());}
+#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+  void pop_front() {
+    _Node* __node = __STATIC_CAST(_Node*, this->_M_head._M_data._M_next);
+    this->_M_head._M_data._M_next = __node->_M_next;
+    _STLP_STD::_Destroy(&__node->_M_data);
+    this->_M_head.deallocate(__node, 1);
+  }
+
+  iterator previous(const_iterator __pos) {
+    return iterator(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos._M_node));
+  }
+  const_iterator previous(const_iterator __pos) const {
+    return const_iterator(__CONST_CAST(_Node_base*,
+                                       _STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data,
+                                                                               __pos._M_node)));
+  }
+
+private:
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  _Node* _M_insert_after(_Node_base* __pos, const value_type& __x = _Tp()) {
+#else
+  _Node* _M_insert_after(_Node_base* __pos, const value_type& __x) {
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+    return __STATIC_CAST(_Node*, _STLP_PRIV __slist_make_link(__pos, _M_create_node(__x)));
+  }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+  _Node* _M_insert_after(_Node_base* __pos) {
+    return __STATIC_CAST(_Node*, _STLP_PRIV __slist_make_link(__pos, _M_create_node()));
+  }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+  void _M_insert_after_fill(_Node_base* __pos,
+                            size_type __n, const value_type& __x) {
+    for (size_type __i = 0; __i < __n; ++__i)
+      __pos = _STLP_PRIV __slist_make_link(__pos, _M_create_node(__x));
+  }
+
+#if defined (_STLP_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 _IsIntegral<_InIter>::_Ret _Integral;
+    _M_insert_after_range(__pos, __first, __last, _Integral());
+  }
+
+  template <class _Integer>
+  void _M_insert_after_range(_Node_base* __pos, _Integer __n, _Integer __x,
+                             const __true_type&) {
+    _M_insert_after_fill(__pos, __n, __x);
+  }
+
+  template <class _InIter>
+  void _M_insert_after_range(_Node_base* __pos,
+                             _InIter __first, _InIter __last,
+                             const __false_type&) {
+#else /* _STLP_MEMBER_TEMPLATES */
+  void _M_insert_after_range(_Node_base* __pos,
+                             const value_type* __first,
+                             const value_type* __last) {
+    while (__first != __last) {
+      __pos = _STLP_PRIV __slist_make_link(__pos, _M_create_node(*__first));
+      ++__first;
+    }
+  }
+  void _M_insert_after_range(_Node_base* __pos,
+                             const_iterator __first, const_iterator __last) {
+#endif /* _STLP_MEMBER_TEMPLATES */
+    while (__first != __last) {
+      __pos = _STLP_PRIV __slist_make_link(__pos, _M_create_node(*__first));
+      ++__first;
+    }
+  }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  // Check whether it's an integral type.  If so, it's not an iterator.
+  template <class _InIter>
+  void _M_splice_after_range(_Node_base* __pos,
+                             _InIter __first, _InIter __last) {
+    typedef typename _IsIntegral<_InIter>::_Ret _Integral;
+    _M_splice_after_range(__pos, __first, __last, _Integral());
+  }
+
+  template <class _Integer>
+  void _M_splice_after_range(_Node_base* __pos, _Integer __n, _Integer __x,
+                             const __true_type&) {
+    _M_insert_after_fill(__pos, __n, __x);
+  }
+
+  template <class _InIter>
+  void _M_splice_after_range(_Node_base* __pos,
+                             _InIter __first, _InIter __last,
+                             const __false_type&) {
+#else /* _STLP_MEMBER_TEMPLATES */
+  void _M_splice_after_range(_Node_base* __pos,
+                             const value_type* __first,
+                             const value_type* __last) {
+    while (__first != __last) {
+      __pos = _STLP_PRIV __slist_make_link(__pos, _M_create_node(*__first));
+      ++__first;
+    }
+  }
+  void _M_splice_after_range(_Node_base* __pos,
+                             const_iterator __first, const_iterator __last) {
+#endif /* _STLP_MEMBER_TEMPLATES */
+    //We use a temporary slist to avoid the auto reference troubles (infinite loop)
+    _Self __tmp(__first, __last, this->get_allocator());
+    splice_after(iterator(__pos), __tmp);
+  }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  // Check whether it's an integral type.  If so, it's not an iterator.
+  template <class _InIter>
+  void _M_splice_range(_Node_base* __pos,
+                       _InIter __first, _InIter __last) {
+    typedef typename _IsIntegral<_InIter>::_Ret _Integral;
+    _M_splice_range(__pos, __first, __last, _Integral());
+  }
+
+  template <class _Integer>
+  void _M_splice_range(_Node_base* __pos, _Integer __n, _Integer __x,
+                       const __true_type&) {
+    _M_insert_after_fill(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos),
+                         __n, __x);
+  }
+
+  template <class _InIter>
+  void _M_splice_range(_Node_base* __pos,
+                       _InIter __first, _InIter __last,
+                       const __false_type&) {
+#else /* _STLP_MEMBER_TEMPLATES */
+  void _M_splice_range(_Node_base* __pos,
+                       const value_type* __first,
+                       const value_type* __last) {
+    while (__first != __last) {
+      __pos = _STLP_PRIV __slist_make_link(__pos, _M_create_node(*__first));
+      ++__first;
+    }
+  }
+  void _M_splice_range(_Node_base* __pos,
+                       const_iterator __first, const_iterator __last) {
+#endif /* _STLP_MEMBER_TEMPLATES */
+    //We use a temporary slist to avoid the auto reference troubles (infinite loop)
+    _Self __tmp(__first, __last, this->get_allocator());
+    splice(iterator(__pos), __tmp);
+  }
+
+public:
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  iterator insert_after(iterator __pos, const value_type& __x = _Tp()) {
+#else
+  iterator insert_after(iterator __pos, const value_type& __x) {
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+    return iterator(_M_insert_after(__pos._M_node, __x));
+  }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+  iterator insert_after(iterator __pos) {
+    return insert_after(__pos, _STLP_DEFAULT_CONSTRUCTED(_Tp));
+  }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+  void insert_after(iterator __pos, size_type __n, const value_type& __x) {
+    _M_insert_after_fill(__pos._M_node, __n, __x);
+  }
+
+#if defined (_STLP_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) {
+#else /* _STLP_MEMBER_TEMPLATES */
+  void insert_after(iterator __pos,
+                    const value_type* __first, const value_type* __last) {
+    _M_insert_after_range(__pos._M_node, __first, __last);
+  }
+  void insert_after(iterator __pos,
+                    const_iterator __first, const_iterator __last) {
+#endif /* _STLP_MEMBER_TEMPLATES */
+    _M_splice_after_range(__pos._M_node, __first, __last);
+  }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  iterator insert(iterator __pos, const value_type& __x = _Tp()) {
+#else
+  iterator insert(iterator __pos, const value_type& __x) {
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+    return iterator(_M_insert_after(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos._M_node),
+                    __x));
+  }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+  iterator insert(iterator __pos) {
+    return iterator(_M_insert_after(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos._M_node),
+                                    _STLP_DEFAULT_CONSTRUCTED(_Tp)));
+  }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+  void insert(iterator __pos, size_type __n, const value_type& __x) {
+    _M_insert_after_fill(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos._M_node), __n, __x);
+  }
+
+#if defined (_STLP_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) {
+#else /* _STLP_MEMBER_TEMPLATES */
+  void insert(iterator __pos, const value_type* __first,
+                              const value_type* __last) {
+    _M_insert_after_range(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos._M_node),
+                          __first, __last);
+  }
+  void insert(iterator __pos, const_iterator __first, const_iterator __last) {
+#endif /* _STLP_MEMBER_TEMPLATES */
+    _M_splice_range(__pos._M_node, __first, __last);
+  }
+
+public:
+  iterator erase_after(iterator __pos)
+  { return iterator(this->_M_erase_after(__pos._M_node)); }
+  iterator erase_after(iterator __before_first, iterator __last)
+  { return iterator(this->_M_erase_after(__before_first._M_node, __last._M_node)); }
+
+  iterator erase(iterator __pos)
+  { return iterator(this->_M_erase_after(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos._M_node))); }
+  iterator erase(iterator __first, iterator __last)
+  { return iterator(this->_M_erase_after(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __first._M_node), __last._M_node)); }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  void resize(size_type new_size, const value_type& __x = _Tp());
+#else
+  void resize(size_type new_size, const value_type& __x);
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+  void resize(size_type new_size) { resize(new_size, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+  void clear()
+  { this->_M_erase_after(&this->_M_head._M_data, 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, _Self& __x,
+                    iterator __before_first, iterator __before_last) {
+    if (__before_first != __before_last) {
+      if (this->get_allocator() == __x.get_allocator()) {
+        _STLP_PRIV _Sl_global_inst::__splice_after(__pos._M_node,
+                                                   __before_first._M_node, __before_last._M_node);
+      }
+      else {
+        this->insert_after(__pos, iterator(__before_first._M_node->_M_next), iterator(__before_last._M_node->_M_next));
+        __x.erase_after(__before_first, ++__before_last);
+      }
+    }
+  }
+
+  // Moves the element that follows __prev to *this, inserting it immediately
+  //  after __pos.  This is constant time.
+  void splice_after(iterator __pos, _Self& __x, iterator __prev) {
+    if (this->get_allocator() == __x.get_allocator()) {
+      _STLP_PRIV _Sl_global_inst::__splice_after(__pos._M_node,
+                                                 __prev._M_node, __prev._M_node->_M_next);
+    }
+    else {
+      this->insert_after(__pos, __STATIC_CAST(_Node*, __prev._M_node->_M_next)->_M_data);
+      __x.erase_after(__prev);
+    }
+  }
+
+  // Removes all of the elements from the list __x to *this, inserting
+  // them immediately after __pos.  __x must not be *this.  Complexity:
+  // linear in __x.size().
+  void splice_after(iterator __pos, _Self& __x) {
+    if (this->get_allocator() == __x.get_allocator())
+      _STLP_PRIV _Sl_global_inst::__splice_after(__pos._M_node, &__x._M_head._M_data);
+    else {
+      this->insert_after(__pos, __x.begin(), __x.end());
+      __x.clear();
+    }
+  }
+
+  // Linear in distance(begin(), __pos), and linear in __x.size().
+  void splice(iterator __pos, _Self& __x) {
+    if (__x._M_head._M_data._M_next) {
+      if (this->get_allocator() == __x.get_allocator()) {
+        _STLP_PRIV _Sl_global_inst::__splice_after(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos._M_node),
+                                                   &__x._M_head._M_data,
+                                                   _STLP_PRIV _Sl_global_inst::__previous(&__x._M_head._M_data, 0));
+      }
+      else {
+        insert(__pos, __x.begin(), __x.end());
+        __x.clear();
+      }
+    }
+  }
+
+  // Linear in distance(begin(), __pos), and in distance(__x.begin(), __i).
+  void splice(iterator __pos, _Self& __x, iterator __i) {
+    if (this->get_allocator() == __x.get_allocator()) {
+      _STLP_PRIV _Sl_global_inst::__splice_after(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos._M_node),
+                                                 _STLP_PRIV _Sl_global_inst::__previous(&__x._M_head._M_data, __i._M_node),
+                                                 __i._M_node);
+    }
+    else {
+      insert(__pos, *__i);
+      __x.erase(__i);
+    }
+  }
+
+  // Linear in distance(begin(), __pos), in distance(__x.begin(), __first),
+  // and in distance(__first, __last).
+  void splice(iterator __pos, _Self& __x, iterator __first, iterator __last) {
+    if (__first != __last) {
+      if (this->get_allocator() == __x.get_allocator()) {
+        _STLP_PRIV _Sl_global_inst::__splice_after(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos._M_node),
+                                                   _STLP_PRIV _Sl_global_inst::__previous(&__x._M_head._M_data, __first._M_node),
+                                                   _STLP_PRIV _Sl_global_inst::__previous(__first._M_node, __last._M_node));
+      }
+      else {
+        insert(__pos, __first, __last);
+        __x.erase(__first, __last);
+      }
+    }
+  }
+
+public:
+  void reverse() {
+    if (this->_M_head._M_data._M_next)
+      this->_M_head._M_data._M_next = _STLP_PRIV _Sl_global_inst::__reverse(this->_M_head._M_data._M_next);
+  }
+
+  void remove(const _Tp& __val);
+
+  void unique() { _STLP_PRIV _Slist_unique(*this, equal_to<value_type>()); }
+  void merge(_Self& __x) { _STLP_PRIV _Slist_merge(*this, __x, less<value_type>()); }
+  void sort() { _STLP_PRIV _Slist_sort(*this, less<value_type>()); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _Predicate>
+  void remove_if(_Predicate __pred) {
+    _Node_base* __cur = &this->_M_head._M_data;
+    while (__cur->_M_next) {
+      if (__pred(__STATIC_CAST(_Node*, __cur->_M_next)->_M_data))
+        this->_M_erase_after(__cur);
+      else
+        __cur = __cur->_M_next;
+    }
+  }
+
+  template <class _BinaryPredicate>
+  void unique(_BinaryPredicate __pred)
+  { _STLP_PRIV _Slist_unique(*this, __pred); }
+
+  template <class _StrictWeakOrdering>
+  void merge(_Self& __x, _StrictWeakOrdering __comp)
+  { _STLP_PRIV _Slist_merge(*this, __x, __comp); }
+
+  template <class _StrictWeakOrdering>
+  void sort(_StrictWeakOrdering __comp)
+  { _STLP_PRIV _Slist_sort(*this, __comp); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+};
+
+#if defined (slist)
+#  undef slist
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+#  include <stl/_slist.c>
+#endif
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+#  include <stl/pointers/_slist.h>
+#endif
+
+#if defined (_STLP_DEBUG)
+#  include <stl/debug/_slist.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _Tp, class _Alloc>
+inline bool  _STLP_CALL
+operator == (const slist<_Tp,_Alloc>& _SL1, const slist<_Tp,_Alloc>& _SL2) {
+  typedef typename slist<_Tp,_Alloc>::const_iterator const_iterator;
+  const_iterator __end1 = _SL1.end();
+  const_iterator __end2 = _SL2.end();
+
+  const_iterator __i1 = _SL1.begin();
+  const_iterator __i2 = _SL2.begin();
+  while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2) {
+    ++__i1;
+    ++__i2;
+  }
+  return __i1 == __end1 && __i2 == __end2;
+}
+
+#define _STLP_EQUAL_OPERATOR_SPECIALIZED
+#define _STLP_TEMPLATE_HEADER    template <class _Tp, class _Alloc>
+#define _STLP_TEMPLATE_CONTAINER slist<_Tp, _Alloc>
+#include <stl/_relops_cont.h>
+#undef _STLP_TEMPLATE_CONTAINER
+#undef _STLP_TEMPLATE_HEADER
+#undef _STLP_EQUAL_OPERATOR_SPECIALIZED
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+#  if !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Tp, class _Alloc>
+struct __move_traits<slist<_Tp, _Alloc> > {
+  typedef __true_type implemented;
+  typedef typename __move_traits<_Alloc>::complete complete;
+};
+#  endif
+
+// Specialization of insert_iterator so that insertions will be constant
+// time rather than linear time.
+template <class _Tp, class _Alloc>
+class insert_iterator<slist<_Tp, _Alloc> > {
+protected:
+  typedef slist<_Tp, _Alloc> _Container;
+  _Container* _M_container;
+  typename _Container::iterator _M_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)
+    : _M_container(&__x) {
+    if (__i == __x.begin())
+      _M_iter = __x.before_begin();
+    else
+      _M_iter = __x.previous(__i);
+  }
+
+  insert_iterator<_Container>&
+  operator = (const typename _Container::value_type& __val) {
+    _M_iter = _M_container->insert_after(_M_iter, __val);
+    return *this;
+  }
+
+  insert_iterator<_Container>& operator*() { return *this; }
+  insert_iterator<_Container>& operator++() { return *this; }
+  insert_iterator<_Container>& operator++(int) { return *this; }
+};
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_SLIST_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_slist_base.c b/stlport/stlport/stl/_slist_base.c
new file mode 100644
index 0000000..e0e68c9
--- /dev/null
+++ b/stlport/stlport/stl/_slist_base.c
@@ -0,0 +1,104 @@
+/*
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_SLIST_BASE_C
+#define _STLP_SLIST_BASE_C
+
+#ifndef _STLP_INTERNAL_SLIST_BASE_H
+#  include <stl/_slist_base.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Dummy>
+_Slist_node_base*  _STLP_CALL
+_Sl_global<_Dummy>::__previous(_Slist_node_base* __head,
+                               const _Slist_node_base* __node) {
+  while (__head && __head->_M_next != __node)
+    __head = __head->_M_next;
+  return __head;
+}
+
+template <class _Dummy>
+void _STLP_CALL
+_Sl_global<_Dummy>::__splice_after(_Slist_node_base* __pos, _Slist_node_base* __head) {
+  _Slist_node_base* __before_last = __previous(__head, 0);
+  if (__before_last != __head) {
+    _Slist_node_base* __after = __pos->_M_next;
+    __pos->_M_next = __head->_M_next;
+    __head->_M_next = 0;
+    __before_last->_M_next = __after;
+  }
+}
+
+template <class _Dummy>
+void _STLP_CALL
+_Sl_global<_Dummy>::__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;
+  }
+}
+
+template <class _Dummy>
+_Slist_node_base* _STLP_CALL
+_Sl_global<_Dummy>::__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;
+}
+
+template <class _Dummy>
+size_t _STLP_CALL
+_Sl_global<_Dummy>::size(_Slist_node_base* __node) {
+  size_t __result = 0;
+  for ( ; __node != 0; __node = __node->_M_next)
+    ++__result;
+  return __result;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /*  _STLP_SLIST_BASE_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_slist_base.h b/stlport/stlport/stl/_slist_base.h
new file mode 100644
index 0000000..3afa18a
--- /dev/null
+++ b/stlport/stlport/stl/_slist_base.h
@@ -0,0 +1,90 @@
+/*
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_SLIST_BASE_H
+#define _STLP_INTERNAL_SLIST_BASE_H
+
+#ifndef _STLP_INTERNAL_CSTDDEF
+#  include <stl/_cstddef.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+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;
+}
+
+
+template <class _Dummy>
+class _Sl_global {
+public:
+  // those used to be global functions
+  // moved here to reduce code bloat without templatizing _Slist_iterator_base
+  static size_t _STLP_CALL size(_Slist_node_base* __node);
+  static _Slist_node_base* _STLP_CALL __reverse(_Slist_node_base* __node);
+  static void _STLP_CALL __splice_after(_Slist_node_base* __pos,
+                                        _Slist_node_base* __before_first,
+                                        _Slist_node_base* __before_last);
+
+  static void _STLP_CALL __splice_after(_Slist_node_base* __pos, _Slist_node_base* __head);
+
+  static _Slist_node_base* _STLP_CALL __previous(_Slist_node_base* __head,
+                                                 const _Slist_node_base* __node);
+  static const _Slist_node_base* _STLP_CALL __previous(const _Slist_node_base* __head,
+                                                       const _Slist_node_base* __node) {
+    return _Sl_global<_Dummy>::__previous(__CONST_CAST(_Slist_node_base*, __head), __node);
+  }
+};
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS _Sl_global<bool>;
+#endif
+
+typedef _Sl_global<bool> _Sl_global_inst;
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION) && defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)
+#  include <stl/_slist_base.c>
+#endif
+
+#endif /* _STLP_INTERNAL_SLIST_BASE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_stack.h b/stlport/stlport/stl/_stack.h
new file mode 100644
index 0000000..7ea9d59
--- /dev/null
+++ b/stlport/stlport/stl/_stack.h
@@ -0,0 +1,133 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_STACK_H
+#define _STLP_INTERNAL_STACK_H
+
+#ifndef _STLP_INTERNAL_DEQUE_H
+#  include <stl/_deque.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if !defined ( _STLP_LIMITED_DEFAULT_TEMPLATES )
+template <class _Tp, class _Sequence = deque<_Tp> >
+#elif defined ( _STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS )
+#  define _STLP_STACK_ARGS _Tp
+template <class _Tp>
+#else
+template <class _Tp, class _Sequence>
+#endif
+class stack
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+#  if defined (_STLP_STACK_ARGS)
+            : public __stlport_class<stack<_Tp> >
+#  else
+            : public __stlport_class<stack<_Tp, _Sequence> >
+#  endif
+#endif
+{
+#ifdef _STLP_STACK_ARGS
+  typedef deque<_Tp> _Sequence;
+  typedef stack<_Tp> _Self;
+#else
+  typedef stack<_Tp, _Sequence> _Self;
+#endif
+
+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:
+  //c is a Standard name (23.2.3.3), do no make it STLport naming convention compliant.
+  _Sequence c;
+public:
+  stack() : c() {}
+  explicit stack(const _Sequence& __s) : c(__s) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+  stack(__move_source<_Self> src)
+    : c(_STLP_PRIV _AsMoveSource(src.get().c)) {}
+#endif
+
+  bool empty() const { return c.empty(); }
+  size_type size() const { return c.size(); }
+  reference top() { return c.back(); }
+  const_reference top() const { return c.back(); }
+  void push(const value_type& __x) { c.push_back(__x); }
+  void pop() { c.pop_back(); }
+  const _Sequence& _Get_s() const { return c; }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+  void _M_swap_workaround(_Self& __x) {
+    _Sequence __tmp = c;
+    c = __x.c;
+    __x.c = __tmp;
+  }
+#endif
+};
+
+#ifndef _STLP_STACK_ARGS
+#  define _STLP_STACK_ARGS _Tp, _Sequence
+#  define _STLP_STACK_HEADER_ARGS class _Tp, class _Sequence
+#else
+#  define _STLP_STACK_HEADER_ARGS class _Tp
+#endif
+
+template < _STLP_STACK_HEADER_ARGS >
+inline bool _STLP_CALL  operator==(const stack< _STLP_STACK_ARGS >& __x,
+                                   const stack< _STLP_STACK_ARGS >& __y)
+{ return __x._Get_s() == __y._Get_s(); }
+
+template < _STLP_STACK_HEADER_ARGS >
+inline bool _STLP_CALL  operator<(const stack< _STLP_STACK_ARGS >& __x,
+                                  const stack< _STLP_STACK_ARGS >& __y)
+{ return __x._Get_s() < __y._Get_s(); }
+
+_STLP_RELOPS_OPERATORS(template < _STLP_STACK_HEADER_ARGS >, stack< _STLP_STACK_ARGS >)
+
+#undef _STLP_STACK_ARGS
+#undef _STLP_STACK_HEADER_ARGS
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Tp, class _Sequence>
+struct __move_traits<stack<_Tp, _Sequence> > :
+  _STLP_PRIV __move_traits_aux<_Sequence>
+{};
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_STACK_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_string.c b/stlport/stlport/stl/_string.c
new file mode 100644
index 0000000..4fa5ece
--- /dev/null
+++ b/stlport/stlport/stl/_string.c
@@ -0,0 +1,673 @@
+/*
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+#ifndef _STLP_STRING_C
+#define _STLP_STRING_C
+
+#ifndef _STLP_INTERNAL_STRING_H
+#  include <stl/_string.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CTRAITS_FUNCTIONS_H
+#  include <stl/_ctraits_fns.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_H
+#  include <stl/_function.h>
+#endif
+
+#if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+#  define basic_string _STLP_NO_MEM_T_NAME(str)
+#elif defined (_STLP_DEBUG)
+#  define basic_string _STLP_NON_DBG_NAME(str)
+#endif
+
+#if defined (_STLP_NESTED_TYPE_PARAM_BUG)
+#  define __size_type__ size_t
+#  define size_type size_t
+#  define iterator _CharT*
+#else
+#  define __size_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_string<_CharT,_Traits,_Alloc>::size_type
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// A helper class to use a char_traits as a function object.
+template <class _Traits>
+struct _Not_within_traits : public unary_function<typename _Traits::char_type, bool> {
+  typedef typename _Traits::char_type _CharT;
+  const _CharT* _M_first;
+  const _CharT* _M_last;
+
+  _Not_within_traits(const _CharT* __f, const _CharT* __l)
+    : _M_first(__f), _M_last(__l) {}
+
+  bool operator()(const _CharT& __x) const {
+    return find_if(_M_first, _M_last,
+                   _STLP_PRIV _Eq_char_bound<_Traits>(__x)) == _M_last;
+  }
+};
+
+template <class _InputIter, class _CharT, class _Traits>
+inline _InputIter __str_find_first_of_aux(_InputIter __first1, _InputIter __last1,
+                                          const _CharT* __first2, const _CharT* __last2,
+                                          _Traits*, const __true_type& /* _STLportTraits */)
+{ return __find_first_of(__first1, __last1, __first2, __last2); }
+
+template <class _InputIter, class _CharT, class _Traits>
+inline _InputIter __str_find_first_of_aux(_InputIter __first1, _InputIter __last1,
+                                          const _CharT* __first2, const _CharT* __last2,
+                                          _Traits*, const __false_type& /* _STLportTraits */)
+{ return __find_first_of(__first1, __last1, __first2, __last2, _STLP_PRIV _Eq_traits<_Traits>()); }
+
+template <class _InputIter, class _CharT, class _Traits>
+inline _InputIter __str_find_first_of(_InputIter __first1, _InputIter __last1,
+                                      const _CharT* __first2, const _CharT* __last2,
+                                      _Traits* __traits) {
+#if !defined (__BORLANDC__)
+  typedef typename _IsSTLportClass<_Traits>::_Ret _STLportTraits;
+#else
+  enum { _Is = _IsSTLportClass<_Traits>::_Is };
+  typedef typename __bool2type<_Is>::_Ret _STLportTraits;
+#endif
+  return __str_find_first_of_aux(__first1, __last1, __first2, __last2, __traits, _STLportTraits());
+}
+
+template <class _InputIter, class _CharT, class _Traits>
+inline _InputIter __str_find_first_not_of_aux3(_InputIter __first1, _InputIter __last1,
+                                               const _CharT* __first2, const _CharT* __last2,
+                                               _Traits* /* __traits */, const __true_type& __useStrcspnLikeAlgo)
+{ return __find_first_of_aux2(__first1, __last1, __first2, __last2, __first2, not1(_Identity<bool>()), __useStrcspnLikeAlgo); }
+
+template <class _InputIter, class _CharT, class _Traits>
+inline _InputIter __str_find_first_not_of_aux3(_InputIter __first1, _InputIter __last1,
+                                               const _CharT* __first2, const _CharT* __last2,
+                                               _Traits* /* __traits */, const __false_type& /* _UseStrcspnLikeAlgo */)
+{ return _STLP_STD::find_if(__first1, __last1, _STLP_PRIV _Not_within_traits<_Traits>(__first2, __last2)); }
+
+template <class _InputIter, class _CharT, class _Tp, class _Traits>
+inline _InputIter __str_find_first_not_of_aux2(_InputIter __first1, _InputIter __last1,
+                                               const _CharT* __first2, const _CharT* __last2,
+                                               _Tp* __pt, _Traits* __traits) {
+  typedef typename _IsIntegral<_Tp>::_Ret _IsIntegral;
+  typedef typename _IsCharLikeType<_CharT>::_Ret _IsCharLike;
+  typedef typename _Land2<_IsIntegral, _IsCharLike>::_Ret _UseStrcspnLikeAlgo;
+  return __str_find_first_not_of_aux3(__first1, __last1, __first2, __last2, __traits, _UseStrcspnLikeAlgo());
+}
+
+template <class _InputIter, class _CharT, class _Traits>
+inline _InputIter __str_find_first_not_of_aux1(_InputIter __first1, _InputIter __last1,
+                                               const _CharT* __first2, const _CharT* __last2,
+                                               _Traits* __traits, const __true_type& /* _STLportTraits */)
+{ return __str_find_first_not_of_aux2(__first1, __last1, __first2, __last2,
+                                      _STLP_VALUE_TYPE(__first1, _InputIter), __traits); }
+
+template <class _InputIter, class _CharT, class _Traits>
+inline _InputIter __str_find_first_not_of_aux1(_InputIter __first1, _InputIter __last1,
+                                               const _CharT* __first2, const _CharT* __last2,
+                                               _Traits*, const __false_type& /* _STLportTraits */)
+{ return _STLP_STD::find_if(__first1, __last1, _STLP_PRIV _Not_within_traits<_Traits>(__first2, __last2)); }
+
+template <class _InputIter, class _CharT, class _Traits>
+inline _InputIter __str_find_first_not_of(_InputIter __first1, _InputIter __last1,
+                                          const _CharT* __first2, const _CharT* __last2,
+                                          _Traits* __traits) {
+#if !defined (__BORLANDC__)
+  typedef typename _IsSTLportClass<_Traits>::_Ret _STLportTraits;
+#else
+  enum { _Is = _IsSTLportClass<_Traits>::_Is };
+  typedef typename __bool2type<_Is>::_Ret _STLportTraits;
+#endif
+  return __str_find_first_not_of_aux1(__first1, __last1, __first2, __last2, __traits, _STLportTraits());
+}
+
+// ------------------------------------------------------------
+// Non-inline declarations.
+
+#if !defined (basic_string)
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+// Change the string's capacity so that it is large enough to hold
+//  at least __res_arg elements, plus the terminating _CharT().  Note that,
+//  if __res_arg < capacity(), this member function may actually decrease
+//  the string's capacity.
+template <class _CharT, class _Traits, class _Alloc>
+void basic_string<_CharT,_Traits,_Alloc>::reserve(size_type __res_arg) {
+  if (__res_arg > max_size())
+    this->_M_throw_length_error();
+
+  size_type __n = (max)(__res_arg, size()) + 1;
+  if (__n < this->_M_capacity())
+    return;
+
+  _M_reserve(__n);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+void basic_string<_CharT,_Traits,_Alloc>::_M_reserve(size_type __n) {
+  pointer __new_start = this->_M_start_of_storage.allocate(__n, __n);
+  pointer __new_finish = _STLP_PRIV __ucopy(this->_M_Start(), this->_M_Finish(), __new_start);
+  _M_construct_null(__new_finish);
+  this->_M_deallocate_block();
+  this->_M_reset(__new_start, __new_finish, __new_start + __n);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_string<_CharT,_Traits,_Alloc>&
+basic_string<_CharT,_Traits,_Alloc>::append(size_type __n, _CharT __c) {
+  if (__n > 0) {
+    if (__n > max_size() - size())
+      this->_M_throw_length_error();
+    if (__n >= this->_M_rest())
+      _M_reserve(_M_compute_next_size(__n));
+    _STLP_PRIV __uninitialized_fill_n(this->_M_finish + 1, __n - 1, __c);
+    _M_construct_null(this->_M_finish + __n);
+    _Traits::assign(*end(), __c);
+    this->_M_finish += __n;
+  }
+  return *this;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_string<_CharT, _Traits, _Alloc>&
+basic_string<_CharT, _Traits, _Alloc>::_M_append(const _CharT* __first, const _CharT* __last) {
+  if (__first != __last) {
+    size_type __n = __STATIC_CAST(size_type, __last - __first);
+    if (__n >= this->_M_rest()) {
+      size_type __len = _M_compute_next_size(__n);
+      pointer __new_start = this->_M_start_of_storage.allocate(__len, __len);
+      pointer __new_finish = _STLP_PRIV __ucopy(this->_M_Start(), this->_M_Finish(), __new_start);
+      __new_finish = _STLP_PRIV __ucopy(__first, __last, __new_finish);
+      _M_construct_null(__new_finish);
+      this->_M_deallocate_block();
+      this->_M_reset(__new_start, __new_finish, __new_start + __len);
+    }
+    else {
+      const _CharT* __f1 = __first;
+      ++__f1;
+      _STLP_PRIV __ucopy(__f1, __last, this->_M_finish + 1);
+      _M_construct_null(this->_M_finish + __n);
+      _Traits::assign(*end(), *__first);
+      this->_M_finish += __n;
+    }
+  }
+  return *this;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_string<_CharT,_Traits,_Alloc>&
+basic_string<_CharT,_Traits,_Alloc>::assign(size_type __n, _CharT __c) {
+  if (__n <= size()) {
+    _Traits::assign(this->_M_Start(), __n, __c);
+    erase(begin() + __n, end());
+  }
+  else {
+    if (__n < capacity()) {
+      _Traits::assign(this->_M_Start(), size(), __c);
+      append(__n - size(), __c);
+    }
+    else {
+      _Self __str(__n, __c);
+      this->swap(__str);
+    }
+  }
+  return *this;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_string<_CharT,_Traits,_Alloc>&
+basic_string<_CharT,_Traits,_Alloc>::_M_assign(const _CharT* __f, const _CharT* __l) {
+  ptrdiff_t __n = __l - __f;
+  if (__STATIC_CAST(size_type, __n) <= size()) {
+    _Traits::copy(this->_M_Start(), __f, __n);
+    erase(begin() + __n, end());
+  }
+  else {
+    _Traits::copy(this->_M_Start(), __f, size());
+    _M_append(__f + size(), __l);
+  }
+  return *this;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+_CharT* basic_string<_CharT,_Traits,_Alloc> ::_M_insert_aux(_CharT* __p,
+                                                            _CharT __c) {
+  pointer __new_pos = __p;
+  if (this->_M_rest() > 1 ) {
+    _M_construct_null(this->_M_finish + 1);
+    _Traits::move(__p + 1, __p, this->_M_finish - __p);
+    _Traits::assign(*__p, __c);
+    ++this->_M_finish;
+  }
+  else {
+    size_type __len = _M_compute_next_size(1);
+    pointer __new_start = this->_M_start_of_storage.allocate(__len, __len);
+    __new_pos = _STLP_PRIV __ucopy(this->_M_Start(), __p, __new_start);
+    _Traits::assign(*__new_pos, __c);
+    pointer __new_finish = __new_pos + 1;
+    __new_finish = _STLP_PRIV __ucopy(__p, this->_M_finish, __new_finish);
+    _M_construct_null(__new_finish);
+    this->_M_deallocate_block();
+    this->_M_reset(__new_start, __new_finish, __new_start + __len);
+  }
+  return __new_pos;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+void basic_string<_CharT,_Traits,_Alloc>::insert(iterator __pos,
+                                                 size_t __n, _CharT __c) {
+  if (__n != 0) {
+    if (this->_M_rest() > __n) {
+      const size_type __elems_after = this->_M_finish - __pos;
+      pointer __old_finish = this->_M_finish;
+      if (__elems_after >= __n) {
+        _STLP_PRIV __ucopy((this->_M_finish - __n) + 1, this->_M_finish + 1, this->_M_finish + 1);
+        this->_M_finish += __n;
+        _Traits::move(__pos + __n, __pos, (__elems_after - __n) + 1);
+        _Traits::assign(__pos, __n, __c);
+      }
+      else {
+        _STLP_PRIV __uninitialized_fill_n(this->_M_finish + 1, __n - __elems_after - 1, __c);
+        this->_M_finish += __n - __elems_after;
+        _STLP_PRIV __ucopy(__pos, __old_finish + 1, this->_M_finish);
+        this->_M_finish += __elems_after;
+        _Traits::assign(__pos, __elems_after + 1, __c);
+      }
+    }
+    else {
+      size_type __len = _M_compute_next_size(__n);
+      pointer __new_start = this->_M_start_of_storage.allocate(__len, __len);
+      pointer __new_finish = _STLP_PRIV __ucopy(this->_M_Start(), __pos, __new_start);
+      __new_finish = _STLP_PRIV __uninitialized_fill_n(__new_finish, __n, __c);
+      __new_finish = _STLP_PRIV __ucopy(__pos, this->_M_finish, __new_finish);
+      _M_construct_null(__new_finish);
+      this->_M_deallocate_block();
+      this->_M_reset(__new_start, __new_finish, __new_start + __len);
+    }
+  }
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+void basic_string<_CharT,_Traits,_Alloc>::_M_insert(iterator __pos,
+                                                    const _CharT* __first, const _CharT* __last,
+                                                    bool __self_ref) {
+  //this version has to take care about the auto referencing
+  if (__first != __last) {
+    const size_t __n = __last - __first;
+    if (this->_M_rest() > __n) {
+      const size_t __elems_after = this->_M_finish - __pos;
+      pointer __old_finish = this->_M_finish;
+      if (__elems_after >= __n) {
+        _STLP_PRIV __ucopy((this->_M_finish - __n) + 1, this->_M_finish + 1, this->_M_finish + 1);
+        this->_M_finish += __n;
+        _Traits::move(__pos + __n, __pos, (__elems_after - __n) + 1);
+        if (!__self_ref || __last < __pos) {
+          _M_copy(__first, __last, __pos);
+        }
+        else {
+          //We have to check that the source buffer hasn't move
+          if (__first >= __pos) {
+            //The source buffer has move
+            __first += __n;
+            __last += __n;
+            _M_copy(__first, __last, __pos);
+          }
+          else {
+            //The source buffer hasn't move, it has been duplicated
+            _M_move(__first, __last, __pos);
+          }
+        }
+      }
+      else {
+        const_iterator __mid = __first;
+        __mid += __elems_after + 1;
+        _STLP_PRIV __ucopy(__mid, __last, this->_M_finish + 1);
+        this->_M_finish += __n - __elems_after;
+        _STLP_PRIV __ucopy(__pos, __old_finish + 1, this->_M_finish);
+        this->_M_finish += __elems_after;
+        if (!__self_ref)
+          _M_copy(__first, __mid, __pos);
+        else
+          _M_move(__first, __mid, __pos);
+      }
+    }
+    else {
+      size_type __len = _M_compute_next_size(__n);
+      pointer __new_start = this->_M_start_of_storage.allocate(__len, __len);
+      pointer __new_finish = _STLP_PRIV __ucopy(this->_M_Start(), __pos, __new_start);
+      __new_finish = _STLP_PRIV __ucopy(__first, __last, __new_finish);
+      __new_finish = _STLP_PRIV __ucopy(__pos, this->_M_finish, __new_finish);
+      _M_construct_null(__new_finish);
+      this->_M_deallocate_block();
+      this->_M_reset(__new_start, __new_finish, __new_start + __len);
+    }
+  }
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_string<_CharT,_Traits,_Alloc>&
+basic_string<_CharT,_Traits,_Alloc> ::replace(iterator __first, iterator __last,
+                                              size_type __n, _CharT __c) {
+  size_type __len = (size_type)(__last - __first);
+
+  if (__len >= __n) {
+    _Traits::assign(__first, __n, __c);
+    erase(__first + __n, __last);
+  }
+  else {
+    _Traits::assign(__first, __len, __c);
+    insert(__last, __n - __len, __c);
+  }
+  return *this;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_string<_CharT,_Traits,_Alloc>&
+basic_string<_CharT,_Traits,_Alloc> ::_M_replace(iterator __first, iterator __last,
+                                                 const _CharT* __f, const _CharT* __l,
+                                                 bool __self_ref) {
+  const ptrdiff_t       __n = __l - __f;
+  const difference_type __len = __last - __first;
+  if (__len >= __n) {
+    if (!__self_ref || __l < __first || __f >= __last)
+      _M_copy(__f, __l, __first);
+    else
+      _M_move(__f, __l, __first);
+    erase(__first + __n, __last);
+  } else if (!__self_ref || (__f >= __last) || (__l <= __first)) { // no overlap
+    const_iterator __m = __f + __len;
+    _M_copy(__f, __m, __first);
+    _M_insert(__last, __m, __l, __self_ref );
+  } else if (__f < __first) { // we have to take care of overlaping
+    const_iterator __m = __f + __len;
+    // We have to deal with possible reallocation because we do insert first.
+    const difference_type __off_dest = __first - this->begin();
+    const difference_type __off_src = __f - this->begin();
+    _M_insert(__last, __m, __l, true);
+    _Traits::move(begin() + __off_dest, begin() + __off_src, __len);
+  } else {
+    const_iterator __m = __f + __len;
+    _Traits::move(__first, __f, __len);
+    _M_insert(__last, __m, __l, true);
+  }
+  return *this;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+__size_type__ basic_string<_CharT,_Traits,_Alloc>::find( const _CharT* __s, size_type __pos,
+                                                         size_type __n) const
+{
+  const size_t __len = size();
+  if (__pos >= __len || __pos + __n > __len) {
+    if ( __n == 0 && __pos <= __len ) { // marginal case
+      return __pos;
+    }
+    return npos;
+  }
+
+  const_pointer __result =
+    _STLP_STD::search(this->_M_Start() + __pos, this->_M_Finish(),
+                      __s, __s + __n, _STLP_PRIV _Eq_traits<_Traits>());
+  return __result != this->_M_Finish() ? __result - this->_M_Start() : npos;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+__size_type__ basic_string<_CharT,_Traits,_Alloc>::find(_CharT __c, size_type __pos) const
+{
+  if (__pos >= size()) { /*__pos + 1 > size()*/
+    return npos;
+  }
+
+  const_pointer __result =
+    _STLP_STD::find_if(this->_M_Start() + __pos, this->_M_Finish(),
+                       _STLP_PRIV _Eq_char_bound<_Traits>(__c));
+  return __result != this->_M_Finish() ? __result - this->_M_Start() : npos;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+__size_type__ basic_string<_CharT,_Traits,_Alloc>::rfind(const _CharT* __s, size_type __pos,
+                                                         size_type __n) const
+{
+  const size_type __len = size();
+  if ( __len < __n ) {
+    return npos;
+  }
+  const_pointer __last = this->_M_Start() + (min)( __len - __n, __pos) + __n;
+  if ( __n == 0 ) { // marginal case
+    return __last - this->_M_Start();
+  }
+  const_pointer __result = _STLP_STD::find_end(this->_M_Start(), __last,
+                                               __s, __s + __n, _STLP_PRIV _Eq_traits<_Traits>());
+  return __result != __last ? __result - this->_M_Start() : npos;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+__size_type__ basic_string<_CharT,_Traits,_Alloc>::rfind(_CharT __c, size_type __pos) const
+{
+  const size_type __len = size();
+  if ( __len < 1 ) {
+    return npos;
+  }
+  const_iterator __last = begin() + (min)(__len - 1, __pos) + 1;
+  const_reverse_iterator __rresult =
+    _STLP_STD::find_if(const_reverse_iterator(__last), rend(),
+                       _STLP_PRIV _Eq_char_bound<_Traits>(__c));
+  return __rresult != rend() ? (__rresult.base() - 1) - begin() : npos;
+}
+
+template <class _CharT, class _Traits, class _Alloc> __size_type__
+basic_string<_CharT,_Traits,_Alloc> ::find_first_of(const _CharT* __s, size_type __pos,
+                                                    size_type __n) const {
+  if (__pos >= size()) /*__pos + 1 > size()*/
+    return npos;
+  else {
+    const_iterator __result = _STLP_PRIV __str_find_first_of(begin() + __pos, end(),
+                                                             __s, __s + __n,
+                                                             __STATIC_CAST(_Traits*, 0));
+    return __result != end() ? __result - begin() : npos;
+  }
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+ __size_type__
+basic_string<_CharT,_Traits,_Alloc> ::find_last_of(const _CharT* __s, size_type __pos,
+                                                   size_type __n) const
+{
+  const size_type __len = size();
+  if ( __len < 1 ) {
+    return npos;
+  }
+  const const_iterator __last = begin() + (min)(__len - 1, __pos) + 1;
+  const const_reverse_iterator __rresult =
+    _STLP_PRIV __str_find_first_of(const_reverse_iterator(__last), rend(),
+                                   __s, __s + __n,
+                                   __STATIC_CAST(_Traits*, 0));
+  return __rresult != rend() ? (__rresult.base() - 1) - begin() : npos;
+}
+
+
+template <class _CharT, class _Traits, class _Alloc> __size_type__
+basic_string<_CharT,_Traits,_Alloc> ::find_first_not_of(const _CharT* __s, size_type __pos,
+                                                        size_type __n) const {
+  typedef typename _Traits::char_type _CharType;
+  if (__pos >= size()) /*__pos + 1 >= size()*/
+    return npos;
+  else {
+    const_pointer __result = _STLP_PRIV __str_find_first_not_of(this->_M_Start() + __pos, this->_M_Finish(),
+                                                                __STATIC_CAST(const _CharType*, __s),
+                                                                __STATIC_CAST(const _CharType*, __s) + __n,
+                                                                __STATIC_CAST(_Traits*, 0));
+    return __result != this->_M_finish ? __result - this->_M_Start() : npos;
+  }
+}
+
+template <class _CharT, class _Traits, class _Alloc> __size_type__
+basic_string<_CharT,_Traits,_Alloc> ::find_first_not_of(_CharT __c, size_type __pos) const {
+  if (1 > size())
+    return npos;
+  else {
+    const_pointer __result = _STLP_STD::find_if(this->_M_Start() + __pos, this->_M_Finish(),
+                                                _STLP_PRIV _Neq_char_bound<_Traits>(__c));
+    return __result != this->_M_finish ? __result - this->_M_Start() : npos;
+  }
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+__size_type__
+basic_string<_CharT,_Traits,_Alloc>::find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+{
+  typedef typename _Traits::char_type _CharType;
+  const size_type __len = size();
+  if ( __len < 1 ) {
+    return npos;
+  }
+  const_iterator __last = begin() + (min)(__len - 1, __pos) + 1;
+  const_reverse_iterator __rlast = const_reverse_iterator(__last);
+  const_reverse_iterator __rresult =
+    _STLP_PRIV __str_find_first_not_of(__rlast, rend(),
+                                       __STATIC_CAST(const _CharType*, __s),
+                                       __STATIC_CAST(const _CharType*, __s) + __n,
+                                       __STATIC_CAST(_Traits*, 0));
+  return __rresult != rend() ? (__rresult.base() - 1) - begin() : npos;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+__size_type__
+basic_string<_CharT, _Traits, _Alloc>::find_last_not_of(_CharT __c, size_type __pos) const
+{
+  const size_type __len = size();
+  if ( __len < 1 ) {
+    return npos;
+  }
+  const_iterator __last = begin() + (min)(__len - 1, __pos) + 1;
+  const_reverse_iterator __rlast = const_reverse_iterator(__last);
+  const_reverse_iterator __rresult =
+    _STLP_STD::find_if(__rlast, rend(),
+                       _STLP_PRIV _Neq_char_bound<_Traits>(__c));
+  return __rresult != rend() ? (__rresult.base() - 1) - begin() : npos;
+}
+
+#if !defined (basic_string)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+template <class _CharT, class _Traits, class _Alloc>
+void _STLP_CALL _S_string_copy(const basic_string<_CharT,_Traits,_Alloc>& __s,
+                               _CharT* __buf, size_t __n) {
+  if (__n > 0) {
+    __n = (min) (__n - 1, __s.size());
+    _STLP_STD::copy(__s.begin(), __s.begin() + __n, __buf);
+    __buf[__n] = _CharT();
+  }
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#include <stl/_range_errors.h>
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// _String_base methods
+template <class _Tp, class _Alloc>
+void _String_base<_Tp,_Alloc>::_M_throw_length_error() const
+{ __stl_throw_length_error("basic_string"); }
+
+template <class _Tp, class _Alloc>
+void _String_base<_Tp, _Alloc>::_M_throw_out_of_range() const
+{ __stl_throw_out_of_range("basic_string"); }
+
+template <class _Tp, class _Alloc>
+void _String_base<_Tp, _Alloc>::_M_allocate_block(size_t __n) {
+  if ((__n <= (max_size() + 1)) && (__n > 0)) {
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+    if (__n > _DEFAULT_SIZE) {
+      this->_M_start_of_storage._M_data = _M_start_of_storage.allocate(__n, __n);
+      this->_M_finish = this->_M_start_of_storage._M_data;
+      this->_M_buffers._M_end_of_storage = this->_M_start_of_storage._M_data + __n;
+    }
+#else
+    this->_M_start_of_storage._M_data = _M_start_of_storage.allocate(__n, __n);
+    this->_M_finish = this->_M_start_of_storage._M_data;
+    this->_M_end_of_storage = this->_M_start_of_storage._M_data + __n;
+#endif
+  } else {
+    this->_M_throw_length_error();
+  }
+}
+
+#if !defined (basic_string)
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+template <class _CharT, class _Traits, class _Alloc>
+basic_string<_CharT, _Traits, _Alloc>::basic_string(const _CharT* __s)
+  : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  _M_range_initialize(__s, __s + traits_type::length(__s));
+}
+#endif
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_string<_CharT, _Traits, _Alloc>::basic_string(const _CharT* __s,
+                                                    const allocator_type& __a)
+  : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  _M_range_initialize(__s, __s + traits_type::length(__s));
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_string<_CharT, _Traits, _Alloc>::basic_string(const basic_string<_CharT, _Traits, _Alloc> & __s)
+  : _STLP_PRIV _String_base<_CharT,_Alloc>(__s.get_allocator())
+{ _M_range_initialize(__s._M_Start(), __s._M_Finish()); }
+
+#if defined (basic_string)
+_STLP_MOVE_TO_STD_NAMESPACE
+#  undef basic_string
+#endif
+
+#if !defined (_STLP_STATIC_CONST_INIT_BUG) && !defined (_STLP_NO_STATIC_CONST_DEFINITION)
+template <class _CharT, class _Traits, class _Alloc>
+const size_t basic_string<_CharT, _Traits, _Alloc>::npos;
+#endif
+
+_STLP_END_NAMESPACE
+
+#undef __size_type__
+#if defined (_STLP_NESTED_TYPE_PARAM_BUG)
+#  undef size_type
+#  undef iterator
+#endif
+
+#endif /*  _STLP_STRING_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_string.h b/stlport/stlport/stl/_string.h
new file mode 100644
index 0000000..540822b
--- /dev/null
+++ b/stlport/stlport/stl/_string.h
@@ -0,0 +1,1182 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_STRING_H
+#define _STLP_INTERNAL_STRING_H
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+#  include <stl/_alloc.h>
+#endif
+
+#ifndef _STLP_STRING_FWD_H
+#  include <stl/_string_fwd.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+#  include <stl/_function_base.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+#  include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_H
+#  include <stl/_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_UNINITIALIZED_H
+#  include <stl/_uninitialized.h>
+#endif
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+#  include <stl/_string_sum.h>
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+#if defined (__MWERKS__) && ! defined (_STLP_USE_OWN_NAMESPACE)
+
+// MSL implementation classes expect to see the definition of streampos
+// when this header is included. We expect this to be fixed in later MSL
+// implementations
+#  if !defined( __MSL_CPP__ ) || __MSL_CPP__ < 0x4105
+#    include <stl/msl_string.h>
+#  endif
+#endif // __MWERKS__
+
+/*
+ * Standard C++ string class.  This class has performance
+ * characteristics very much like vector<>, meaning, for example, that
+ * it does not perform reference-count or copy-on-write, and that
+ * concatenation of two strings is an O(N) operation.
+
+ * There are three reasons why basic_string is not identical to
+ * vector.
+ * First, basic_string always stores a null character at the end;
+ * this makes it possible for c_str to be a fast operation.
+ * Second, the C++ standard requires basic_string to copy elements
+ * using char_traits<>::assign, char_traits<>::copy, and
+ * char_traits<>::move.  This means that all of vector<>'s low-level
+ * operations must be rewritten.  Third, basic_string<> has a lot of
+ * extra functions in its interface that are convenient but, strictly
+ * speaking, redundant.
+ */
+
+#include <stl/_string_base.h>
+
+_STLP_BEGIN_NAMESPACE
+
+// ------------------------------------------------------------
+// Class basic_string.
+
+// Class invariants:
+// (1) [start, finish) is a valid range.
+// (2) Each iterator in [start, finish) points to a valid object
+//     of type value_type.
+// (3) *finish is a valid object of type value_type; when
+//     value_type is not a POD it is value_type().
+// (4) [finish + 1, end_of_storage) is a valid range.
+// (5) Each iterator in [finish + 1, end_of_storage) points to
+//     unininitialized memory.
+
+// Note one important consequence: a string of length n must manage
+// a block of memory whose size is at least n + 1.
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+struct _String_reserve_t {};
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+#  define basic_string _STLP_NO_MEM_T_NAME(str)
+#elif defined (_STLP_DEBUG)
+#  define basic_string _STLP_NON_DBG_NAME(str)
+#endif
+
+#if defined (basic_string)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+#if defined (__DMC__)
+#  define _STLP_PRIVATE public
+#elif defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+#  define _STLP_PRIVATE protected
+#else
+#  define _STLP_PRIVATE private
+#endif
+
+template <class _CharT, class _Traits, class _Alloc>
+class basic_string : _STLP_PRIVATE _STLP_PRIV _String_base<_CharT,_Alloc>
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (basic_string)
+                   , public __stlport_class<basic_string<_CharT, _Traits, _Alloc> >
+#endif
+{
+_STLP_PRIVATE:                        // Private members inherited from base.
+  typedef _STLP_PRIV _String_base<_CharT,_Alloc> _Base;
+  typedef basic_string<_CharT, _Traits, _Alloc> _Self;
+
+public:
+  typedef _CharT value_type;
+  typedef _Traits traits_type;
+
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef typename _Base::size_type size_type;
+  typedef ptrdiff_t difference_type;
+  typedef random_access_iterator_tag _Iterator_category;
+
+  typedef const value_type* const_iterator;
+  typedef value_type*       iterator;
+
+  _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS;
+
+#include <stl/_string_npos.h>
+
+  typedef _STLP_PRIV _String_reserve_t _Reserve_t;
+
+public:                         // Constructor, destructor, assignment.
+  typedef typename _Base::allocator_type allocator_type;
+
+  allocator_type get_allocator() const
+  { return _STLP_CONVERT_ALLOCATOR((const allocator_type&)this->_M_start_of_storage, _CharT); }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  explicit basic_string(const allocator_type& __a = allocator_type())
+#else
+  basic_string()
+      : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type(), _Base::_DEFAULT_SIZE)
+  { _M_terminate_string(); }
+  explicit basic_string(const allocator_type& __a)
+#endif
+      : _STLP_PRIV _String_base<_CharT,_Alloc>(__a, _Base::_DEFAULT_SIZE)
+  { _M_terminate_string(); }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  basic_string(_Reserve_t, size_t __n,
+               const allocator_type& __a = allocator_type())
+#else
+  basic_string(_Reserve_t, size_t __n)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type(), __n + 1)
+  { _M_terminate_string(); }
+  basic_string(_Reserve_t, size_t __n, const allocator_type& __a)
+#endif
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(__a, __n + 1)
+  { _M_terminate_string(); }
+
+  basic_string(const _Self&);
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  basic_string(const _Self& __s, size_type __pos, size_type __n = npos,
+               const allocator_type& __a = allocator_type())
+#else
+  basic_string(const _Self& __s, size_type __pos)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) {
+    if (__pos > __s.size())
+      this->_M_throw_out_of_range();
+    else
+      _M_range_initialize(__s._M_Start() + __pos, __s._M_Finish());
+  }
+  basic_string(const _Self& __s, size_type __pos, size_type __n)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) {
+    if (__pos > __s.size())
+      this->_M_throw_out_of_range();
+    else
+      _M_range_initialize(__s._M_Start() + __pos,
+                          __s._M_Start() + __pos + (min) (__n, __s.size() - __pos));
+  }
+  basic_string(const _Self& __s, size_type __pos, size_type __n,
+               const allocator_type& __a)
+#endif
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) {
+    if (__pos > __s.size())
+      this->_M_throw_out_of_range();
+    else
+      _M_range_initialize(__s._M_Start() + __pos,
+                          __s._M_Start() + __pos + (min) (__n, __s.size() - __pos));
+  }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  basic_string(const _CharT* __s, size_type __n,
+               const allocator_type& __a = allocator_type())
+#else
+  basic_string(const _CharT* __s, size_type __n)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) {
+      _STLP_FIX_LITERAL_BUG(__s)
+      _M_range_initialize(__s, __s + __n);
+    }
+  basic_string(const _CharT* __s, size_type __n, const allocator_type& __a)
+#endif
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) {
+      _STLP_FIX_LITERAL_BUG(__s)
+      _M_range_initialize(__s, __s + __n);
+    }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  basic_string(const _CharT* __s,
+               const allocator_type& __a = allocator_type());
+#else
+  basic_string(const _CharT* __s);
+  basic_string(const _CharT* __s, const allocator_type& __a);
+#endif
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  basic_string(size_type __n, _CharT __c,
+               const allocator_type& __a = allocator_type())
+#else
+  basic_string(size_type __n, _CharT __c)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type(), __n + 1) {
+    this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_Start(), __n, __c);
+    _M_terminate_string();
+  }
+  basic_string(size_type __n, _CharT __c, const allocator_type& __a)
+#endif
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(__a, __n + 1) {
+    this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_Start(), __n, __c);
+    _M_terminate_string();
+  }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+  basic_string(__move_source<_Self> src)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(__move_source<_Base>(src.get())) {}
+#endif
+
+  // Check to see if _InputIterator is an integer type.  If so, then
+  // it can't be an iterator.
+#if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+  template <class _InputIterator>
+  basic_string(_InputIterator __f, _InputIterator __l,
+               const allocator_type & __a _STLP_ALLOCATOR_TYPE_DFL)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) {
+    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+    _M_initialize_dispatch(__f, __l, _Integral());
+  }
+#  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+  template <class _InputIterator>
+  basic_string(_InputIterator __f, _InputIterator __l)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) {
+    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+    _M_initialize_dispatch(__f, __l, _Integral());
+  }
+#  endif
+#else
+#  if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+  basic_string(const _CharT* __f, const _CharT* __l,
+               const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) {
+    _STLP_FIX_LITERAL_BUG(__f)  _STLP_FIX_LITERAL_BUG(__l)
+    _M_range_initialize(__f, __l);
+  }
+#    if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+  basic_string(const _CharT* __f, const _CharT* __l)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) {
+    _STLP_FIX_LITERAL_BUG(__f)  _STLP_FIX_LITERAL_BUG(__l)
+    _M_range_initialize(__f, __l);
+  }
+#    endif
+#  endif
+#  if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+  /* We need an additionnal constructor to build an empty string without
+   * any allocation or termination char*/
+protected:
+  struct _CalledFromWorkaround_t {};
+  basic_string(_CalledFromWorkaround_t, const allocator_type &__a)
+    : _String_base<_CharT,_Alloc>(__a) {}
+#  endif
+#endif
+
+_STLP_PRIVATE:
+  size_type _M_compute_next_size(size_type __n) {
+    const size_type __size = size();
+    if (__n > max_size() - __size)
+      this->_M_throw_length_error();
+    size_type __len = __size + (max)(__n, __size) + 1;
+    if (__len > max_size() || __len < __size)
+      __len = max_size(); // overflow
+    return __len;
+  }
+
+  template <class _InputIter>
+  void _M_range_initialize(_InputIter __f, _InputIter __l,
+                           const input_iterator_tag &__tag) {
+    this->_M_allocate_block();
+    _M_construct_null(this->_M_Finish());
+    _M_appendT(__f, __l, __tag);
+  }
+
+  template <class _ForwardIter>
+  void _M_range_initialize(_ForwardIter __f, _ForwardIter __l,
+                           const forward_iterator_tag &) {
+    difference_type __n = _STLP_STD::distance(__f, __l);
+    this->_M_allocate_block(__n + 1);
+    this->_M_finish = uninitialized_copy(__f, __l, this->_M_Start());
+    this->_M_terminate_string();
+  }
+
+  template <class _InputIter>
+  void _M_range_initializeT(_InputIter __f, _InputIter __l) {
+    _M_range_initialize(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter));
+  }
+
+  template <class _Integer>
+  void _M_initialize_dispatch(_Integer __n, _Integer __x, const __true_type& /*_Integral*/) {
+    this->_M_allocate_block(__n + 1);
+    this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_Start(), __n, __x);
+    this->_M_terminate_string();
+  }
+
+  template <class _InputIter>
+  void _M_initialize_dispatch(_InputIter __f, _InputIter __l, const __false_type& /*_Integral*/) {
+    _M_range_initializeT(__f, __l);
+  }
+
+public:
+  _Self& operator=(const _Self& __s) {
+    if (&__s != this)
+      _M_assign(__s._M_Start(), __s._M_Finish());
+    return *this;
+  }
+
+  _Self& operator=(const _CharT* __s) {
+    _STLP_FIX_LITERAL_BUG(__s)
+    return _M_assign(__s, __s + traits_type::length(__s));
+  }
+
+  _Self& operator=(_CharT __c)
+  { return assign(__STATIC_CAST(size_type,1), __c); }
+
+private:
+  static _CharT _STLP_CALL _M_null()
+  { return _STLP_DEFAULT_CONSTRUCTED(_CharT); }
+
+_STLP_PRIVATE:                     // Helper functions used by constructors
+                                   // and elsewhere.
+  void _M_construct_null(_CharT* __p) const
+  { _STLP_STD::_Construct(__p); }
+  void _M_terminate_string()
+  { _M_construct_null(this->_M_Finish()); }
+  bool _M_inside(const _CharT* __s) const {
+    _STLP_FIX_LITERAL_BUG(__s)
+    return (__s >= this->_M_Start()) && (__s < this->_M_Finish());
+  }
+
+  void _M_range_initialize(const _CharT* __f, const _CharT* __l) {
+    _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+    ptrdiff_t __n = __l - __f;
+    this->_M_allocate_block(__n + 1);
+    this->_M_finish = uninitialized_copy(__f, __l, this->_M_Start());
+    _M_terminate_string();
+  }
+
+public:                         // Iterators.
+  iterator begin()             { return this->_M_Start(); }
+  iterator end()               { return this->_M_Finish(); }
+  const_iterator begin() const { return this->_M_Start(); }
+  const_iterator end()   const { return this->_M_Finish(); }
+
+  reverse_iterator rbegin()
+  { return reverse_iterator(this->_M_Finish()); }
+  reverse_iterator rend()
+  { return reverse_iterator(this->_M_Start()); }
+  const_reverse_iterator rbegin() const
+  { return const_reverse_iterator(this->_M_Finish()); }
+  const_reverse_iterator rend()   const
+  { return const_reverse_iterator(this->_M_Start()); }
+
+public:                         // Size, capacity, etc.
+  size_type size() const     { return this->_M_Finish() - this->_M_Start(); }
+  size_type length() const   { return size(); }
+  size_type max_size() const { return _Base::max_size(); }
+
+  void resize(size_type __n, _CharT __c) {
+    if (__n <= size())
+      erase(begin() + __n, end());
+    else
+      append(__n - size(), __c);
+  }
+
+  void resize(size_type __n) { resize(__n, _M_null()); }
+
+private:
+  void _M_reserve(size_type);
+public:
+  void reserve(size_type = 0);
+
+  size_type capacity() const
+  { return this->_M_capacity() - 1; }
+
+  void clear() {
+    if (!empty()) {
+      _Traits::assign(*(this->_M_Start()), _M_null());
+      this->_M_finish = this->_M_Start();
+    }
+  }
+
+  bool empty() const { return this->_M_Start() == this->_M_Finish(); }
+
+public:                         // Element access.
+
+  const_reference operator[](size_type __n) const
+  { return *(this->_M_Start() + __n); }
+  reference operator[](size_type __n)
+  { return *(this->_M_Start() + __n); }
+
+  const_reference at(size_type __n) const {
+    if (__n >= size())
+      this->_M_throw_out_of_range();
+    return *(this->_M_Start() + __n);
+  }
+
+  reference at(size_type __n) {
+    if (__n >= size())
+      this->_M_throw_out_of_range();
+    return *(this->_M_Start() + __n);
+  }
+
+public:                         // Append, operator+=, push_back.
+
+  _Self& operator+=(const _Self& __s) { return append(__s); }
+  _Self& operator+=(const _CharT* __s) { _STLP_FIX_LITERAL_BUG(__s) return append(__s); }
+  _Self& operator+=(_CharT __c) { push_back(__c); return *this; }
+
+private:
+  _Self& _M_append(const _CharT* __first, const _CharT* __last);
+
+#if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+  template <class _InputIter>
+  _Self& _M_appendT(_InputIter __first, _InputIter __last,
+                    const input_iterator_tag &) {
+    for ( ; __first != __last ; ++__first)
+      push_back(*__first);
+    return *this;
+  }
+
+  template <class _ForwardIter>
+  _Self& _M_appendT(_ForwardIter __first, _ForwardIter __last,
+                    const forward_iterator_tag &) {
+    if (__first != __last) {
+      size_type __n = __STATIC_CAST(size_type, _STLP_STD::distance(__first, __last));
+      if (__n >= this->_M_rest()) {
+        size_type __len = _M_compute_next_size(__n);
+        pointer __new_start = this->_M_start_of_storage.allocate(__len, __len);
+        pointer __new_finish = uninitialized_copy(this->_M_Start(), this->_M_Finish(), __new_start);
+        __new_finish = uninitialized_copy(__first, __last, __new_finish);
+        _M_construct_null(__new_finish);
+        this->_M_deallocate_block();
+        this->_M_reset(__new_start, __new_finish, __new_start + __len);
+      }
+      else {
+        _Traits::assign(*this->_M_finish, *__first++);
+        uninitialized_copy(__first, __last, this->_M_Finish() + 1);
+        _M_construct_null(this->_M_Finish() + __n);
+        this->_M_finish += __n;
+      }
+    }
+    return *this;
+  }
+
+  template <class _Integer>
+  _Self& _M_append_dispatch(_Integer __n, _Integer __x, const __true_type& /*Integral*/)
+  { return append((size_type) __n, (_CharT) __x); }
+
+  template <class _InputIter>
+  _Self& _M_append_dispatch(_InputIter __f, _InputIter __l, const __false_type& /*Integral*/)
+  { return _M_appendT(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter)); }
+
+public:
+  // Check to see if _InputIterator is an integer type.  If so, then
+  // it can't be an iterator.
+  template <class _InputIter>
+  _Self& append(_InputIter __first, _InputIter __last) {
+    typedef typename _IsIntegral<_InputIter>::_Ret _Integral;
+    return _M_append_dispatch(__first, __last, _Integral());
+  }
+#else
+public:
+  _Self& append(const _CharT* __first, const _CharT* __last) {
+    _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+    return _M_append(__first, __last);
+  }
+#endif
+
+public:
+  _Self& append(const _Self& __s)
+  { return _M_append(__s._M_Start(), __s._M_Finish()); }
+
+  _Self& append(const _Self& __s,
+                size_type __pos, size_type __n) {
+    if (__pos > __s.size())
+      this->_M_throw_out_of_range();
+    return _M_append(__s._M_Start() + __pos,
+                     __s._M_Start() + __pos + (min) (__n, __s.size() - __pos));
+  }
+
+  _Self& append(const _CharT* __s, size_type __n)
+  { _STLP_FIX_LITERAL_BUG(__s) return _M_append(__s, __s+__n); }
+  _Self& append(const _CharT* __s)
+  { _STLP_FIX_LITERAL_BUG(__s) return _M_append(__s, __s + traits_type::length(__s)); }
+  _Self& append(size_type __n, _CharT __c);
+
+public:
+  void push_back(_CharT __c) {
+    if (this->_M_rest() == 1 )
+      _M_reserve(_M_compute_next_size(1));
+    _M_construct_null(this->_M_Finish() + 1);
+    _Traits::assign(*(this->_M_Finish()), __c);
+    ++this->_M_finish;
+  }
+
+  void pop_back() {
+    _Traits::assign(*(this->_M_Finish() - 1), _M_null());
+    --this->_M_finish;
+  }
+
+public:                         // Assign
+  _Self& assign(const _Self& __s)
+  { return _M_assign(__s._M_Start(), __s._M_Finish()); }
+
+  _Self& assign(const _Self& __s,
+                size_type __pos, size_type __n) {
+    if (__pos > __s.size())
+      this->_M_throw_out_of_range();
+    return _M_assign(__s._M_Start() + __pos,
+                     __s._M_Start() + __pos + (min) (__n, __s.size() - __pos));
+  }
+
+  _Self& assign(const _CharT* __s, size_type __n)
+  { _STLP_FIX_LITERAL_BUG(__s) return _M_assign(__s, __s + __n); }
+
+  _Self& assign(const _CharT* __s)
+  { _STLP_FIX_LITERAL_BUG(__s) return _M_assign(__s, __s + _Traits::length(__s)); }
+
+  _Self& assign(size_type __n, _CharT __c);
+
+private:
+  _Self& _M_assign(const _CharT* __f, const _CharT* __l);
+
+#if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+  // Helper functions for assign.
+  template <class _Integer>
+  _Self& _M_assign_dispatch(_Integer __n, _Integer __x, const __true_type& /*_Integral*/)
+  { return assign((size_type) __n, (_CharT) __x); }
+
+  template <class _InputIter>
+  _Self& _M_assign_dispatch(_InputIter __f, _InputIter __l, const __false_type& /*_Integral*/) {
+    pointer __cur = this->_M_Start();
+    while (__f != __l && __cur != this->_M_Finish()) {
+      _Traits::assign(*__cur, *__f);
+      ++__f;
+      ++__cur;
+    }
+    if (__f == __l)
+      erase(__cur, this->end());
+    else
+      _M_appendT(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter));
+    return *this;
+  }
+
+public:
+  // Check to see if _InputIterator is an integer type.  If so, then
+  // it can't be an iterator.
+  template <class _InputIter>
+  _Self& assign(_InputIter __first, _InputIter __last) {
+    typedef typename _IsIntegral<_InputIter>::_Ret _Integral;
+    return _M_assign_dispatch(__first, __last, _Integral());
+  }
+#else
+public:
+  _Self& assign(const _CharT* __f, const _CharT* __l) {
+    _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+    return _M_assign(__f, __l);
+  }
+#endif
+
+public:                         // Insert
+  _Self& insert(size_type __pos, const _Self& __s) {
+    if (__pos > size())
+      this->_M_throw_out_of_range();
+    if (__s.size() > max_size() - size())
+      this->_M_throw_length_error();
+    _M_insert(begin() + __pos, __s._M_Start(), __s._M_Finish(), &__s == this);
+    return *this;
+  }
+
+  _Self& insert(size_type __pos, const _Self& __s,
+                size_type __beg, size_type __n) {
+    if (__pos > size() || __beg > __s.size())
+      this->_M_throw_out_of_range();
+    size_type __len = (min) (__n, __s.size() - __beg);
+    if (__len > max_size() - size())
+      this->_M_throw_length_error();
+    _M_insert(begin() + __pos,
+              __s._M_Start() + __beg, __s._M_Start() + __beg + __len, &__s == this);
+    return *this;
+  }
+  _Self& insert(size_type __pos, const _CharT* __s, size_type __n) {
+    _STLP_FIX_LITERAL_BUG(__s)
+    if (__pos > size())
+      this->_M_throw_out_of_range();
+    if (__n > max_size() - size())
+      this->_M_throw_length_error();
+    _M_insert(begin() + __pos, __s, __s + __n, _M_inside(__s));
+    return *this;
+  }
+
+  _Self& insert(size_type __pos, const _CharT* __s) {
+    _STLP_FIX_LITERAL_BUG(__s)
+    if (__pos > size())
+      this->_M_throw_out_of_range();
+    size_type __len = _Traits::length(__s);
+    if (__len > max_size() - size())
+      this->_M_throw_length_error();
+    _M_insert(this->_M_Start() + __pos, __s, __s + __len, _M_inside(__s));
+    return *this;
+  }
+
+  _Self& insert(size_type __pos, size_type __n, _CharT __c) {
+    if (__pos > size())
+      this->_M_throw_out_of_range();
+    if (__n > max_size() - size())
+      this->_M_throw_length_error();
+    insert(begin() + __pos, __n, __c);
+    return *this;
+  }
+
+  iterator insert(iterator __p, _CharT __c) {
+    _STLP_FIX_LITERAL_BUG(__p)
+    if (__p == end()) {
+      push_back(__c);
+      return this->_M_Finish() - 1;
+    }
+    else
+      return _M_insert_aux(__p, __c);
+  }
+
+  void insert(iterator __p, size_t __n, _CharT __c);
+
+_STLP_PRIVATE:  // Helper functions for insert.
+  void _M_insert(iterator __p, const _CharT* __first, const _CharT* __last, bool __self_ref);
+
+  pointer _M_insert_aux(pointer, _CharT);
+
+  void _M_copy(const _CharT* __f, const _CharT* __l, _CharT* __res) {
+    _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+    _STLP_FIX_LITERAL_BUG(__res)
+    _Traits::copy(__res, __f, __l - __f);
+  }
+
+  void _M_move(const _CharT* __f, const _CharT* __l, _CharT* __res) {
+    _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+    _Traits::move(__res, __f, __l - __f);
+  }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+#  if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+  template <class _ForwardIter>
+  void _M_insert_overflow(iterator __pos, _ForwardIter __first, _ForwardIter __last,
+                          size_type __n) {
+    size_type __len = _M_compute_next_size(__n);
+    pointer __new_start = this->_M_start_of_storage.allocate(__len, __len);
+    pointer __new_finish = uninitialized_copy(this->_M_Start(), __pos, __new_start);
+    __new_finish = uninitialized_copy(__first, __last, __new_finish);
+    __new_finish = uninitialized_copy(__pos, this->_M_Finish(), __new_finish);
+    _M_construct_null(__new_finish);
+    this->_M_deallocate_block();
+    this->_M_reset(__new_start, __new_finish, __new_start + __len);
+  }
+
+  template <class _InputIter>
+  void _M_insertT(iterator __p, _InputIter __first, _InputIter __last,
+                  const input_iterator_tag &) {
+    for ( ; __first != __last; ++__first) {
+      __p = insert(__p, *__first);
+      ++__p;
+    }
+  }
+
+  template <class _ForwardIter>
+  void _M_insertT(iterator __pos, _ForwardIter __first, _ForwardIter __last,
+                  const forward_iterator_tag &) {
+    if (__first != __last) {
+      size_type __n = _STLP_STD::distance(__first, __last);
+      if (__n < this->_M_rest()) {
+        const size_type __elems_after = this->_M_finish - __pos;
+        if (__elems_after >= __n) {
+          uninitialized_copy((this->_M_Finish() - __n) + 1, this->_M_Finish() + 1, this->_M_Finish() + 1);
+          this->_M_finish += __n;
+          _Traits::move(__pos + __n, __pos, (__elems_after - __n) + 1);
+          _M_copyT(__first, __last, __pos);
+        }
+        else {
+          pointer __old_finish = this->_M_Finish();
+          _ForwardIter __mid = __first;
+          _STLP_STD::advance(__mid, __elems_after + 1);
+          _STLP_STD::uninitialized_copy(__mid, __last, this->_M_Finish() + 1);
+          this->_M_finish += __n - __elems_after;
+          uninitialized_copy(__pos, __old_finish + 1, this->_M_Finish());
+          this->_M_finish += __elems_after;
+          _M_copyT(__first, __mid, __pos);
+        }
+      }
+      else {
+        _M_insert_overflow(__pos, __first, __last, __n);
+      }
+    }
+  }
+
+  template <class _Integer>
+  void _M_insert_dispatch(iterator __p, _Integer __n, _Integer __x,
+                          const __true_type& /*Integral*/)
+  { insert(__p, (size_type) __n, (_CharT) __x); }
+
+  template <class _InputIter>
+  void _M_insert_dispatch(iterator __p, _InputIter __first, _InputIter __last,
+                          const __false_type& /*Integral*/) {
+    _STLP_FIX_LITERAL_BUG(__p)
+    /* We are forced to do a temporary string to avoid the self referencing issue. */
+    const _Self __self(__first, __last, get_allocator());
+    _M_insertT(__p, __self.begin(), __self.end(), forward_iterator_tag());
+  }
+
+  template <class _InputIterator>
+  void _M_copyT(_InputIterator __first, _InputIterator __last, pointer __result) {
+    _STLP_FIX_LITERAL_BUG(__result)
+    for ( ; __first != __last; ++__first, ++__result)
+      _Traits::assign(*__result, *__first);
+  }
+
+#    if !defined (_STLP_NO_METHOD_SPECIALIZATION)
+  void _M_copyT(const _CharT* __f, const _CharT* __l, _CharT* __res) {
+    _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+    _STLP_FIX_LITERAL_BUG(__res)
+    _Traits::copy(__res, __f, __l - __f);
+  }
+#    endif
+public:
+  // Check to see if _InputIterator is an integer type.  If so, then
+  // it can't be an iterator.
+  template <class _InputIter>
+  void insert(iterator __p, _InputIter __first, _InputIter __last) {
+    typedef typename _IsIntegral<_InputIter>::_Ret _Integral;
+    _M_insert_dispatch(__p, __first, __last, _Integral());
+  }
+#  endif
+#endif
+
+#if !defined (_STLP_MEMBER_TEMPLATES) || !defined (_STLP_NO_METHOD_SPECIALIZATION)
+public:
+  void insert(iterator __p, const _CharT* __f, const _CharT* __l) {
+    _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+    _M_insert(__p, __f, __l, _M_inside(__f));
+  }
+#endif
+
+public:                         // Erase.
+  _Self& erase(size_type __pos = 0, size_type __n = npos) {
+    if (__pos > size())
+      this->_M_throw_out_of_range();
+    erase(begin() + __pos, begin() + __pos + (min) (__n, size() - __pos));
+    return *this;
+  }
+
+  iterator erase(iterator __pos) {
+    // The move includes the terminating _CharT().
+    _Traits::move(__pos, __pos + 1, this->_M_Finish() - __pos);
+    --this->_M_finish;
+    return __pos;
+  }
+
+  iterator erase(iterator __first, iterator __last) {
+    if (__first != __last) {
+      // The move includes the terminating _CharT().
+      traits_type::move(__first, __last, (this->_M_Finish() - __last) + 1);
+      this->_M_finish = this->_M_Finish() - (__last - __first);
+    }
+    return __first;
+  }
+
+public:                         // Replace.  (Conceptually equivalent
+                                // to erase followed by insert.)
+  _Self& replace(size_type __pos, size_type __n, const _Self& __s) {
+    const size_type __size = size();
+    if (__pos > __size)
+      this->_M_throw_out_of_range();
+    const size_type __len = (min) (__n, __size - __pos);
+    if (__s.size() > max_size() - (__size - __len))
+      this->_M_throw_length_error();
+    return _M_replace(begin() + __pos, begin() + __pos + __len,
+                      __s._M_Start(), __s._M_Finish(), &__s == this);
+  }
+
+  _Self& replace(size_type __pos1, size_type __n1, const _Self& __s,
+                 size_type __pos2, size_type __n2) {
+    const size_type __size1 = size();
+    const size_type __size2 = __s.size();
+    if (__pos1 > __size1 || __pos2 > __size2)
+      this->_M_throw_out_of_range();
+    const size_type __len1 = (min) (__n1, __size1 - __pos1);
+    const size_type __len2 = (min) (__n2, __size2 - __pos2);
+    if (__len2 > max_size() - (__size1 - __len1))
+      this->_M_throw_length_error();
+    return _M_replace(begin() + __pos1, begin() + __pos1 + __len1,
+                      __s._M_Start() + __pos2, __s._M_Start() + __pos2 + __len2, &__s == this);
+  }
+
+  _Self& replace(size_type __pos, size_type __n1,
+                 const _CharT* __s, size_type __n2) {
+    _STLP_FIX_LITERAL_BUG(__s)
+    const size_type __size = size();
+    if (__pos > __size)
+      this->_M_throw_out_of_range();
+    const size_type __len = (min) (__n1, __size - __pos);
+    if (__n2 > max_size() - (__size - __len))
+      this->_M_throw_length_error();
+    return _M_replace(begin() + __pos, begin() + __pos + __len,
+                      __s, __s + __n2, _M_inside(__s));
+  }
+
+  _Self& replace(size_type __pos, size_type __n1, const _CharT* __s) {
+    _STLP_FIX_LITERAL_BUG(__s)
+    return replace(__pos, __n1, __s, _Traits::length(__s));
+  }
+
+  _Self& replace(size_type __pos, size_type __n1,
+                 size_type __n2, _CharT __c) {
+    const size_type __size = size();
+    if (__pos > __size)
+      this->_M_throw_out_of_range();
+    const size_type __len = (min) (__n1, __size - __pos);
+    if (__n2 > max_size() - (__size - __len))
+      this->_M_throw_length_error();
+    return replace(begin() + __pos, begin() + __pos + __len, __n2, __c);
+  }
+
+  _Self& replace(iterator __first, iterator __last, const _Self& __s) {
+    _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+    return _M_replace(__first, __last, __s._M_Start(), __s._M_Finish(), &__s == this);
+  }
+
+  _Self& replace(iterator __first, iterator __last,
+                 const _CharT* __s, size_type __n) {
+    _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+    _STLP_FIX_LITERAL_BUG(__s)
+    return _M_replace(__first, __last, __s, __s + __n, _M_inside(__s));
+  }
+
+  _Self& replace(iterator __first, iterator __last,
+                 const _CharT* __s) {
+    _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+    _STLP_FIX_LITERAL_BUG(__s)
+    return _M_replace(__first, __last, __s, __s + _Traits::length(__s), _M_inside(__s));
+  }
+
+  _Self& replace(iterator __first, iterator __last, size_type __n, _CharT __c);
+
+_STLP_PRIVATE:                        // Helper functions for replace.
+  _Self& _M_replace(iterator __first, iterator __last,
+                    const _CharT* __f, const _CharT* __l, bool __self_ref);
+
+#if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+  template <class _Integer>
+  _Self& _M_replace_dispatch(iterator __first, iterator __last,
+                             _Integer __n, _Integer __x, const __true_type& /*IsIntegral*/) {
+    _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+    return replace(__first, __last, (size_type) __n, (_CharT) __x);
+  }
+
+  template <class _InputIter>
+  _Self& _M_replace_dispatch(iterator __first, iterator __last,
+                             _InputIter __f, _InputIter __l, const __false_type& /*IsIntegral*/) {
+    _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+    /* We are forced to do a temporary string to avoid the self referencing issue. */
+    const _Self __self(__f, __l, get_allocator());
+    return _M_replace(__first, __last, __self._M_Start(), __self._M_Finish(), false);
+  }
+
+public:
+  // Check to see if _InputIter is an integer type.  If so, then
+  // it can't be an iterator.
+  template <class _InputIter>
+  _Self& replace(iterator __first, iterator __last,
+                 _InputIter __f, _InputIter __l) {
+    _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+    typedef typename _IsIntegral<_InputIter>::_Ret _Integral;
+    return _M_replace_dispatch(__first, __last, __f, __l,  _Integral());
+  }
+#endif
+
+#if !defined (_STLP_MEMBER_TEMPLATES) || !defined (_STLP_NO_METHOD_SPECIALIZATION)
+public:
+  _Self& replace(iterator __first, iterator __last,
+                 const _CharT* __f, const _CharT* __l) {
+    _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+    _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+    return _M_replace(__first, __last, __f, __l, _M_inside(__f));
+  }
+#endif
+
+public:                         // Other modifier member functions.
+
+  size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const {
+    _STLP_FIX_LITERAL_BUG(__s)
+    if (__pos > size())
+      this->_M_throw_out_of_range();
+    const size_type __len = (min) (__n, size() - __pos);
+    _Traits::copy(__s, this->_M_Start() + __pos, __len);
+    return __len;
+  }
+
+  void swap(_Self& __s) { this->_M_swap(__s); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+  void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+public:                         // Conversion to C string.
+
+  const _CharT* c_str() const { return this->_M_Start(); }
+  const _CharT* data()  const { return this->_M_Start(); }
+
+public: // find.
+  size_type find(const _Self& __s, size_type __pos = 0) const
+  { return find(__s._M_Start(), __pos, __s.size()); }
+
+  size_type find(const _CharT* __s, size_type __pos = 0) const
+  { _STLP_FIX_LITERAL_BUG(__s) return find(__s, __pos, _Traits::length(__s)); }
+
+  size_type find(const _CharT* __s, size_type __pos, size_type __n) const;
+
+  // WIE: Versant schema compiler 5.2.2 ICE workaround
+  size_type find(_CharT __c) const { return find(__c, 0); }
+  size_type find(_CharT __c, size_type __pos /* = 0 */) const;
+
+public: // rfind.
+  size_type rfind(const _Self& __s, size_type __pos = npos) const
+  { return rfind(__s._M_Start(), __pos, __s.size()); }
+
+  size_type rfind(const _CharT* __s, size_type __pos = npos) const
+  { _STLP_FIX_LITERAL_BUG(__s) return rfind(__s, __pos, _Traits::length(__s)); }
+
+  size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const;
+  size_type rfind(_CharT __c, size_type __pos = npos) const;
+
+public: // find_first_of
+  size_type find_first_of(const _Self& __s, size_type __pos = 0) const
+  { return find_first_of(__s._M_Start(), __pos, __s.size()); }
+
+  size_type find_first_of(const _CharT* __s, size_type __pos = 0) const
+  { _STLP_FIX_LITERAL_BUG(__s) return find_first_of(__s, __pos, _Traits::length(__s)); }
+
+  size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
+
+  size_type find_first_of(_CharT __c, size_type __pos = 0) const
+  { return find(__c, __pos); }
+
+public: // find_last_of
+  size_type find_last_of(const _Self& __s, size_type __pos = npos) const
+  { return find_last_of(__s._M_Start(), __pos, __s.size()); }
+
+  size_type find_last_of(const _CharT* __s, size_type __pos = npos) const
+  { _STLP_FIX_LITERAL_BUG(__s) return find_last_of(__s, __pos, _Traits::length(__s)); }
+
+  size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
+
+  size_type find_last_of(_CharT __c, size_type __pos = npos) const
+  { return rfind(__c, __pos); }
+
+public: // find_first_not_of
+  size_type find_first_not_of(const _Self& __s, size_type __pos = 0) const
+  { return find_first_not_of(__s._M_Start(), __pos, __s.size()); }
+
+  size_type find_first_not_of(const _CharT* __s, size_type __pos = 0) const
+  { _STLP_FIX_LITERAL_BUG(__s) return find_first_not_of(__s, __pos, _Traits::length(__s)); }
+
+  size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const;
+
+  size_type find_first_not_of(_CharT __c, size_type __pos = 0) const;
+
+public: // find_last_not_of
+  size_type find_last_not_of(const _Self& __s, size_type __pos = npos) const
+  { return find_last_not_of(__s._M_Start(), __pos, __s.size()); }
+
+  size_type find_last_not_of(const _CharT* __s, size_type __pos = npos) const
+  { _STLP_FIX_LITERAL_BUG(__s) return find_last_not_of(__s, __pos, _Traits::length(__s)); }
+
+  size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const;
+
+  size_type find_last_not_of(_CharT __c, size_type __pos = npos) const;
+
+public: // Substring.
+  _Self substr(size_type __pos = 0, size_type __n = npos) const
+  { return _Self(*this, __pos, __n, get_allocator()); }
+
+public: // Compare
+  int compare(const _Self& __s) const
+  { return _M_compare(this->_M_Start(), this->_M_Finish(), __s._M_Start(), __s._M_Finish()); }
+
+  int compare(size_type __pos1, size_type __n1, const _Self& __s) const {
+    if (__pos1 > size())
+      this->_M_throw_out_of_range();
+    return _M_compare(this->_M_Start() + __pos1,
+                      this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1),
+                      __s._M_Start(), __s._M_Finish());
+  }
+
+  int compare(size_type __pos1, size_type __n1, const _Self& __s,
+              size_type __pos2, size_type __n2) const {
+    if (__pos1 > size() || __pos2 > __s.size())
+      this->_M_throw_out_of_range();
+    return _M_compare(this->_M_Start() + __pos1,
+                      this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1),
+                      __s._M_Start() + __pos2,
+                      __s._M_Start() + __pos2 + (min) (__n2, __s.size() - __pos2));
+  }
+
+  int compare(const _CharT* __s) const {
+    _STLP_FIX_LITERAL_BUG(__s)
+    return _M_compare(this->_M_Start(), this->_M_Finish(), __s, __s + _Traits::length(__s));
+  }
+
+  int compare(size_type __pos1, size_type __n1, const _CharT* __s) const {
+    _STLP_FIX_LITERAL_BUG(__s)
+    if (__pos1 > size())
+      this->_M_throw_out_of_range();
+    return _M_compare(this->_M_Start() + __pos1,
+                      this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1),
+                      __s, __s + _Traits::length(__s));
+  }
+
+  int compare(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) const {
+    _STLP_FIX_LITERAL_BUG(__s)
+    if (__pos1 > size())
+      this->_M_throw_out_of_range();
+    return _M_compare(this->_M_Start() + __pos1,
+                      this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1),
+                      __s, __s + __n2);
+  }
+
+public: // Helper functions for compare.
+  static int _STLP_CALL _M_compare(const _CharT* __f1, const _CharT* __l1,
+                                   const _CharT* __f2, const _CharT* __l2) {
+    const ptrdiff_t __n1 = __l1 - __f1;
+    const ptrdiff_t __n2 = __l2 - __f2;
+    const int cmp = _Traits::compare(__f1, __f2, (min) (__n1, __n2));
+    return cmp != 0 ? cmp : (__n1 < __n2 ? -1 : (__n1 > __n2 ? 1 : 0));
+  }
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION) && !defined (_STLP_DEBUG) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+#  define _STLP_STRING_SUM_BASE(__reserve, __size, __alloc) _STLP_PRIV _String_base<_CharT,_Alloc>(__alloc, __size + 1)
+#  include <stl/_string_sum_methods.h>
+#  undef _STLP_STRING_SUM_BASE
+#endif
+};
+
+#undef _STLP_PRIVATE
+
+#if defined (__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ == 96)
+template <class _CharT, class _Traits, class _Alloc>
+const size_t basic_string<_CharT, _Traits, _Alloc>::npos = ~(size_t) 0;
+#endif
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS basic_string<char, char_traits<char>, allocator<char> >;
+#  if defined (_STLP_HAS_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >;
+#  endif
+#endif /* _STLP_USE_TEMPLATE_EXPORT */
+
+#if defined (basic_string)
+_STLP_MOVE_TO_STD_NAMESPACE
+#  undef basic_string
+#endif
+
+_STLP_END_NAMESPACE
+
+#if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+#  include <stl/_string_workaround.h>
+#endif
+
+#if defined (_STLP_DEBUG)
+#  include <stl/debug/_string.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+// ------------------------------------------------------------
+// Non-member functions.
+// Swap.
+#if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+template <class _CharT, class _Traits, class _Alloc>
+inline void _STLP_CALL
+swap(basic_string<_CharT,_Traits,_Alloc>& __x,
+     basic_string<_CharT,_Traits,_Alloc>& __y)
+{ __x.swap(__y); }
+#else
+inline void _STLP_CALL swap(string& __x, string& __y)
+{ __x.swap(__y); }
+#  if defined (_STLP_HAS_WCHAR_T)
+inline void _STLP_CALL swap(wstring& __x, wstring& __y)
+{ __x.swap(__y); }
+#  endif
+#endif
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _CharT, class _Traits, class _Alloc>
+struct __move_traits<basic_string<_CharT, _Traits, _Alloc> > {
+  typedef __true_type implemented;
+  //Completness depends on the allocator:
+  typedef typename __move_traits<_Alloc>::complete complete;
+};
+/*#else
+ * There is no need to specialize for string and wstring in this case
+ * as the default __move_traits will already tell that string is movable
+ * but not complete. We cannot define it as complete as nothing guaranty
+ * that the STLport user hasn't specialized std::allocator for char or
+ * wchar_t.
+ */
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _CharT, class _Traits, class _Alloc>
+void _STLP_CALL _S_string_copy(const basic_string<_CharT,_Traits,_Alloc>& __s,
+                               _CharT* __buf, size_t __n);
+
+#if defined(_STLP_USE_WIDE_INTERFACE)
+// A couple of functions to transfer between ASCII/Unicode
+wstring __ASCIIToWide(const char *ascii);
+string __WideToASCII(const wchar_t *wide);
+#endif
+
+inline const char* _STLP_CALL
+__get_c_string(const string& __str) { return __str.c_str(); }
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#include <stl/_string_operators.h>
+
+#if defined(_STLP_USE_NO_IOSTREAMS) || \
+    (defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION))
+#  include <stl/_string.c>
+#endif
+
+#endif /* _STLP_INTERNAL_STRING_H */
+
+/*
+ * Local Variables:
+ * mode:C++
+ * End:
+ */
diff --git a/stlport/stlport/stl/_string_base.h b/stlport/stlport/stl/_string_base.h
new file mode 100644
index 0000000..7c6d7fe
--- /dev/null
+++ b/stlport/stlport/stl/_string_base.h
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_STRING_BASE_H
+#define _STLP_STRING_BASE_H
+
+// ------------------------------------------------------------
+// Class _String_base.
+
+// _String_base is a helper class that makes it it easier to write an
+// exception-safe version of basic_string.  The constructor allocates,
+// but does not initialize, a block of memory.  The destructor
+// deallocates, but does not destroy elements within, a block of
+// memory.  The destructor assumes that _M_start either is null, or else
+// points to a block of memory that was allocated using _String_base's
+// allocator and whose size is _M_end_of_storage - _M_start_of_storage._M_data.
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp, class _Alloc>
+class _String_base {
+    typedef _String_base<_Tp, _Alloc> _Self;
+protected:
+  _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
+public:
+  //dums: Some compiler(MSVC6) require it to be public not simply protected!
+  enum {_DEFAULT_SIZE = 4 * sizeof( void * )};
+  //This is needed by the full move framework
+  typedef _Alloc allocator_type;
+  typedef _STLP_alloc_proxy<_Tp*, _Tp, allocator_type> _AllocProxy;
+  typedef size_t size_type;
+private:
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+  union _Buffers {
+    _Tp*  _M_end_of_storage;
+    _Tp   _M_static_buf[_DEFAULT_SIZE];
+  } _M_buffers;
+#else
+  _Tp*    _M_end_of_storage;
+#endif /* _STLP_USE_SHORT_STRING_OPTIM */
+protected:
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+  bool _M_using_static_buf() const
+  { return (_M_start_of_storage._M_data == _M_buffers._M_static_buf); }
+  _Tp const* _M_Start() const { return _M_start_of_storage._M_data; }
+  _Tp* _M_Start() { return _M_start_of_storage._M_data; }
+  _Tp const* _M_End() const
+  { return _M_using_static_buf() ? _M_buffers._M_static_buf + _DEFAULT_SIZE : _M_buffers._M_end_of_storage; }
+  _Tp* _M_End()
+  { return _M_using_static_buf() ? _M_buffers._M_static_buf + _DEFAULT_SIZE : _M_buffers._M_end_of_storage; }
+  size_type _M_capacity() const
+  { return _M_using_static_buf() ? _DEFAULT_SIZE : _M_buffers._M_end_of_storage - _M_start_of_storage._M_data; }
+  size_type _M_rest() const
+  { return  _M_using_static_buf() ? _DEFAULT_SIZE - (_M_finish - _M_buffers._M_static_buf) : _M_buffers._M_end_of_storage - _M_finish; }
+#else
+  _Tp const* _M_Start() const { return _M_start_of_storage._M_data; }
+  _Tp* _M_Start() { return _M_start_of_storage._M_data; }
+  _Tp const* _M_End() const { return _M_end_of_storage; }
+  _Tp* _M_End() { return _M_end_of_storage; }
+  size_type _M_capacity() const
+  { return _M_end_of_storage - _M_start_of_storage._M_data; }
+  size_type _M_rest() const
+  { return _M_end_of_storage - _M_finish; }
+#endif /* _STLP_USE_SHORT_STRING_OPTIM */
+
+  _Tp*    _M_finish;
+  _AllocProxy _M_start_of_storage;
+
+  _Tp const* _M_Finish() const {return _M_finish;}
+  _Tp* _M_Finish() {return _M_finish;}
+
+  // Precondition: 0 < __n <= max_size().
+  void _M_allocate_block(size_t __n = _DEFAULT_SIZE);
+  void _M_deallocate_block() {
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+    if (!_M_using_static_buf() && (_M_start_of_storage._M_data != 0))
+      _M_start_of_storage.deallocate(_M_start_of_storage._M_data, _M_buffers._M_end_of_storage - _M_start_of_storage._M_data);
+#else
+    if (_M_start_of_storage._M_data != 0)
+      _M_start_of_storage.deallocate(_M_start_of_storage._M_data, _M_end_of_storage - _M_start_of_storage._M_data);
+#endif /* _STLP_USE_SHORT_STRING_OPTIM */
+  }
+
+  size_t max_size() const {
+    const size_type __string_max_size = size_type(-1) / sizeof(_Tp);
+    typename allocator_type::size_type __alloc_max_size = _M_start_of_storage.max_size();
+    return (min)(__alloc_max_size, __string_max_size) - 1;
+  }
+
+  _String_base(const allocator_type& __a)
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+    : _M_finish(_M_buffers._M_static_buf), _M_start_of_storage(__a, _M_buffers._M_static_buf)
+#else
+    : _M_end_of_storage(0), _M_finish(0), _M_start_of_storage(__a, (_Tp*)0)
+#endif
+    {}
+
+  _String_base(const allocator_type& __a, size_t __n)
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+    : _M_finish(_M_buffers._M_static_buf), _M_start_of_storage(__a, _M_buffers._M_static_buf) {
+#else
+    : _M_end_of_storage(0), _M_finish(0), _M_start_of_storage(__a, (_Tp*)0) {
+#endif
+      _M_allocate_block(__n);
+    }
+
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+  void _M_move_src (_Self &src) {
+    if (src._M_using_static_buf()) {
+      _M_buffers = src._M_buffers;
+      _M_finish = _M_buffers._M_static_buf + (src._M_finish - src._M_start_of_storage._M_data);
+      _M_start_of_storage._M_data = _M_buffers._M_static_buf;
+    }
+    else {
+      _M_start_of_storage._M_data = src._M_start_of_storage._M_data;
+      _M_finish = src._M_finish;
+      _M_buffers._M_end_of_storage = src._M_buffers._M_end_of_storage;
+      src._M_start_of_storage._M_data = 0;
+    }
+  }
+#endif
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+  _String_base(__move_source<_Self> src)
+#  if defined (_STLP_USE_SHORT_STRING_OPTIM)
+    : _M_start_of_storage(__move_source<_AllocProxy>(src.get()._M_start_of_storage)) {
+      _M_move_src(src.get());
+#  else
+    : _M_end_of_storage(src.get()._M_end_of_storage), _M_finish(src.get()._M_finish),
+      _M_start_of_storage(__move_source<_AllocProxy>(src.get()._M_start_of_storage)) {
+      src.get()._M_start_of_storage._M_data = 0;
+#  endif
+    }
+#endif
+
+  ~_String_base() { _M_deallocate_block(); }
+
+  void _M_reset(_Tp *__start, _Tp *__finish, _Tp *__end_of_storage) {
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+    _M_buffers._M_end_of_storage = __end_of_storage;
+#else
+    _M_end_of_storage = __end_of_storage;
+#endif
+    _M_finish = __finish;
+    _M_start_of_storage._M_data = __start;
+  }
+
+  void _M_swap(_Self &__s) {
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+    if (_M_using_static_buf()) {
+      if (__s._M_using_static_buf()) {
+        _STLP_STD::swap(_M_buffers, __s._M_buffers);
+        _Tp *__tmp = _M_finish;
+        _M_finish = _M_start_of_storage._M_data + (__s._M_finish - __s._M_start_of_storage._M_data);
+        __s._M_finish = __s._M_buffers._M_static_buf + (__tmp - _M_start_of_storage._M_data);
+        //We need to swap _M_start_of_storage for allocators with state:
+        _M_start_of_storage.swap(__s._M_start_of_storage);
+        _M_start_of_storage._M_data = _M_buffers._M_static_buf;
+        __s._M_start_of_storage._M_data = __s._M_buffers._M_static_buf;
+      } else {
+        __s._M_swap(*this);
+        return;
+      }
+    }
+    else if (__s._M_using_static_buf()) {
+      _Tp *__tmp = _M_start_of_storage._M_data;
+      _Tp *__tmp_finish = _M_finish;
+      _Tp *__tmp_end_data = _M_buffers._M_end_of_storage;
+      _M_buffers = __s._M_buffers;
+      //We need to swap _M_start_of_storage for allocators with state:
+      _M_start_of_storage.swap(__s._M_start_of_storage);
+      _M_start_of_storage._M_data = _M_buffers._M_static_buf;
+      _M_finish = _M_buffers._M_static_buf + (__s._M_finish - __s._M_buffers._M_static_buf);
+      __s._M_buffers._M_end_of_storage = __tmp_end_data;
+      __s._M_start_of_storage._M_data = __tmp;
+      __s._M_finish = __tmp_finish;
+    }
+    else {
+      _STLP_STD::swap(_M_buffers._M_end_of_storage, __s._M_buffers._M_end_of_storage);
+      _M_start_of_storage.swap(__s._M_start_of_storage);
+      _STLP_STD::swap(_M_finish, __s._M_finish);
+    }
+#else
+    _STLP_STD::swap(_M_end_of_storage, __s._M_end_of_storage);
+    _M_start_of_storage.swap(__s._M_start_of_storage);
+    _STLP_STD::swap(_M_finish, __s._M_finish);
+#endif
+  }
+
+  void _STLP_FUNCTION_THROWS _M_throw_length_error() const;
+  void _STLP_FUNCTION_THROWS _M_throw_out_of_range() const;
+};
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS _String_base<char, allocator<char> >;
+#  if defined (_STLP_HAS_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS _String_base<wchar_t, allocator<wchar_t> >;
+#  endif
+#endif /* _STLP_USE_TEMPLATE_EXPORT */
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_STRING_BASE_H */
+
+/*
+ * Local Variables:
+ * mode:C++
+ * End:
+ */
diff --git a/stlport/stlport/stl/_string_fwd.h b/stlport/stlport/stl/_string_fwd.h
new file mode 100644
index 0000000..fe65385
--- /dev/null
+++ b/stlport/stlport/stl/_string_fwd.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_STRING_FWD_H
+#define _STLP_STRING_FWD_H
+
+#ifndef _STLP_INTERNAL_IOSFWD
+#  include <stl/_iosfwd.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if !defined (_STLP_LIMITED_DEFAULT_TEMPLATES)
+template <class _CharT,
+          class _Traits = char_traits<_CharT>,
+          class _Alloc = allocator<_CharT> >
+class basic_string;
+#else
+template <class _CharT,
+          class _Traits,
+          class _Alloc>
+class basic_string;
+#endif /* _STLP_LIMITED_DEFAULT_TEMPLATES */
+
+typedef basic_string<char, char_traits<char>, allocator<char> > string;
+
+#if defined (_STLP_HAS_WCHAR_T)
+typedef basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > wstring;
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+//This function limits header dependency between exception and string
+//implementation. It is implemented in _string.h
+const char* _STLP_CALL __get_c_string(const string& __str);
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_STRING_FWD_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_string_hash.h b/stlport/stlport/stl/_string_hash.h
new file mode 100644
index 0000000..87f2d9f
--- /dev/null
+++ b/stlport/stlport/stl/_string_hash.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_STRING_HASH_H
+#define _STLP_STRING_HASH_H
+
+#ifndef _STLP_HASH_FUN_H
+# include <stl/_hash_fun.h>
+#endif
+
+#ifndef _STLP_INTERNAL_STRING_H
+# include <stl/_string.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _CharT, class _Traits, class _Alloc>
+_STLP_INLINE_LOOP size_t
+__stl_string_hash(const basic_string<_CharT,_Traits,_Alloc>& __s) {
+  unsigned long __h = 0;
+  size_t __len = __s.size();
+  const _CharT* __data = __s.data();
+  for ( size_t __i = 0; __i < __len; ++__i)
+    __h = /* 5 *__h */(__h << 2) + __h + __data[__i];
+  return size_t(__h);
+}
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && \
+  (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x560))
+template <class _CharT, class _Traits, class _Alloc>
+struct hash<basic_string<_CharT,_Traits,_Alloc> > {
+  size_t operator()(const basic_string<_CharT,_Traits,_Alloc>& __s) const
+    { return __stl_string_hash(__s); }
+};
+
+#else
+
+_STLP_TEMPLATE_NULL
+struct _STLP_CLASS_DECLSPEC hash<string> {
+  size_t operator()(const string& __s) const
+    { return __stl_string_hash(__s); }
+};
+
+#  if defined (_STLP_HAS_WCHAR_T)
+_STLP_TEMPLATE_NULL
+struct _STLP_CLASS_DECLSPEC hash<wstring> {
+  size_t operator()(const wstring& __s) const
+    { return __stl_string_hash(__s); }
+};
+#  endif
+
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+_STLP_END_NAMESPACE
+
+#endif
diff --git a/stlport/stlport/stl/_string_npos.h b/stlport/stlport/stl/_string_npos.h
new file mode 100644
index 0000000..faa9c62
--- /dev/null
+++ b/stlport/stlport/stl/_string_npos.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2005
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+/* This header contains npos definition used in basic_string and rope
+ * implementation. It do not have to be guarded as files including it
+ * are already guarded and it has sometimes to be included several times.
+ */
+
+#if defined (_STLP_STATIC_CONST_INIT_BUG)
+  enum { npos = -1 };
+#elif defined (__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ == 96)
+  // inline initializer conflicts with 'extern template'
+  static const size_t npos;
+#else
+  static const size_t npos = ~(size_t)0;
+#endif
diff --git a/stlport/stlport/stl/_string_operators.h b/stlport/stlport/stl/_string_operators.h
new file mode 100644
index 0000000..cff13af
--- /dev/null
+++ b/stlport/stlport/stl/_string_operators.h
@@ -0,0 +1,602 @@
+/*
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_STRING_OPERATORS_H
+#define _STLP_STRING_OPERATORS_H
+
+_STLP_BEGIN_NAMESPACE
+
+#if !defined (_STLP_USE_TEMPLATE_EXPRESSION)
+
+#  if defined (__GNUC__) || defined (__MLCCPP__)
+#    define _STLP_INIT_AMBIGUITY 1
+#  endif
+
+template <class _CharT, class _Traits, class _Alloc>
+inline basic_string<_CharT,_Traits,_Alloc> _STLP_CALL
+operator+(const basic_string<_CharT,_Traits,_Alloc>& __s,
+          const basic_string<_CharT,_Traits,_Alloc>& __y) {
+  typedef basic_string<_CharT,_Traits,_Alloc> _Str;
+  typedef typename _Str::_Reserve_t _Reserve_t;
+#  if defined (_STLP_INIT_AMBIGUITY)
+  // gcc counts this as a function
+  _Str __result  = _Str(_Reserve_t(), __s.size() + __y.size(), __s.get_allocator());
+#  else
+  _Str __result(_Reserve_t(), __s.size() + __y.size(), __s.get_allocator());
+#  endif
+  __result.append(__s);
+  __result.append(__y);
+  return __result;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline basic_string<_CharT,_Traits,_Alloc> _STLP_CALL
+operator+(const _CharT* __s,
+          const basic_string<_CharT,_Traits,_Alloc>& __y) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  typedef basic_string<_CharT,_Traits,_Alloc> _Str;
+  typedef typename _Str::_Reserve_t _Reserve_t;
+  const size_t __n = _Traits::length(__s);
+#  if defined (_STLP_INIT_AMBIGUITY)
+  _Str __result = _Str(_Reserve_t(), __n + __y.size(), __y.get_allocator());
+#  else
+  _Str __result(_Reserve_t(), __n + __y.size(), __y.get_allocator());
+#  endif
+  __result.append(__s, __s + __n);
+  __result.append(__y);
+  return __result;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline basic_string<_CharT,_Traits,_Alloc> _STLP_CALL
+operator+(_CharT __c,
+          const basic_string<_CharT,_Traits,_Alloc>& __y) {
+  typedef basic_string<_CharT,_Traits,_Alloc> _Str;
+  typedef typename _Str::_Reserve_t _Reserve_t;
+#  if defined (_STLP_INIT_AMBIGUITY)
+  _Str __result = _Str(_Reserve_t(), 1 + __y.size(), __y.get_allocator());
+#  else
+  _Str __result(_Reserve_t(), 1 + __y.size(), __y.get_allocator());
+#  endif
+  __result.push_back(__c);
+  __result.append(__y);
+  return __result;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline basic_string<_CharT,_Traits,_Alloc> _STLP_CALL
+operator+(const basic_string<_CharT,_Traits,_Alloc>& __x,
+          const _CharT* __s) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  typedef basic_string<_CharT,_Traits,_Alloc> _Str;
+  typedef typename _Str::_Reserve_t _Reserve_t;
+  const size_t __n = _Traits::length(__s);
+#  if defined (_STLP_INIT_AMBIGUITY)
+  _Str __result = _Str(_Reserve_t(), __x.size() + __n, __x.get_allocator());
+#  else
+  _Str __result(_Reserve_t(), __x.size() + __n, __x.get_allocator());
+#  endif
+  __result.append(__x);
+  __result.append(__s, __s + __n);
+  return __result;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline basic_string<_CharT,_Traits,_Alloc> _STLP_CALL
+operator+(const basic_string<_CharT,_Traits,_Alloc>& __x,
+          const _CharT __c) {
+  typedef basic_string<_CharT,_Traits,_Alloc> _Str;
+  typedef typename _Str::_Reserve_t _Reserve_t;
+#  if defined (_STLP_INIT_AMBIGUITY)
+  _Str __result = _Str(_Reserve_t(), __x.size() + 1, __x.get_allocator());
+#  else
+  _Str __result(_Reserve_t(), __x.size() + 1, __x.get_allocator());
+#  endif
+  __result.append(__x);
+  __result.push_back(__c);
+  return __result;
+}
+
+#  undef _STLP_INIT_AMBIGUITY
+
+#else /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+// addition with basic_string
+template <class _CharT, class _Traits, class _Alloc>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+                             _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+                             _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+                                                   _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+                                                   _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+                                                   _STLP_PRIV __on_right>,
+                             _STLP_PRIV __on_right> _STLP_CALL
+operator+(const basic_string<_CharT,_Traits,_Alloc>& __lhs,
+          const basic_string<_CharT,_Traits,_Alloc>& __rhs) {
+  typedef _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+                                                         _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+                                                         _STLP_PRIV __on_right> __root_type;
+  __root_type __root(__rhs, _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>(__lhs.get_allocator()));
+  return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+                                                        __root_type,
+                                                        _STLP_PRIV __on_right>(__lhs, __root);
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+                             _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+                             _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+                             _STLP_PRIV __on_right> _STLP_CALL
+operator+(const basic_string<_CharT,_Traits,_Alloc>& __lhs,
+          const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __rhs) {
+  return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+                                                        _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+                                                        _STLP_PRIV __on_right>(__lhs, __rhs);
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+                             _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+                             _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+                             _STLP_PRIV __on_left> _STLP_CALL
+operator+(const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __lhs,
+          const basic_string<_CharT,_Traits,_Alloc>& __rhs) {
+  return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+                                                        _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+                                                        _STLP_PRIV __on_left>(__lhs, __rhs);
+}
+
+// addition with C string
+template <class _CharT, class _Traits, class _Alloc>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+                             _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+                             _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+                                                   _STLP_PRIV __cstr_wrapper<_CharT>,
+                                                   _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+                                                   _STLP_PRIV __on_right>,
+                             _STLP_PRIV __on_right> _STLP_CALL
+operator+(const basic_string<_CharT,_Traits,_Alloc>& __x,
+          const _CharT* __s) {
+  const size_t __n = _Traits::length(__s);
+  typedef _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __cstr_wrapper<_CharT>,
+                                                         _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+                                                         _STLP_PRIV __on_right> __root_type;
+  __root_type __root(_STLP_PRIV __cstr_wrapper<_CharT>(__s, __n), _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>(__x.get_allocator()));
+  return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+                                                        __root_type, _STLP_PRIV __on_right>(__x, __root);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+                             _STLP_PRIV __cstr_wrapper<_CharT>,
+                             _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+                                                   _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+                                                   _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+                                                   _STLP_PRIV __on_right>,
+                             _STLP_PRIV __on_right> _STLP_CALL
+operator+(const _CharT* __s,
+          const basic_string<_CharT,_Traits,_Alloc>& __y) {
+  const size_t __n = _Traits::length(__s);
+  typedef _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+                                                         _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+                                                         _STLP_PRIV __on_right> __root_type;
+  __root_type __root(__y, _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>(__y.get_allocator()));
+  return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __cstr_wrapper<_CharT>,
+                                                        __root_type,
+                                                        _STLP_PRIV __on_right>(_STLP_PRIV __cstr_wrapper<_CharT>(__s, __n), __root);
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+                             _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+                             _STLP_PRIV __cstr_wrapper<_CharT>,
+                             _STLP_PRIV __on_left> _STLP_CALL
+operator+(const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __x,
+          const _CharT* __s) {
+  const size_t __n = _Traits::length(__s);
+  return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+                                                        _STLP_PRIV __cstr_wrapper<_CharT>,
+                                                        _STLP_PRIV __on_left>(__x, _STLP_PRIV __cstr_wrapper<_CharT>(__s, __n));
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+                             _STLP_PRIV __cstr_wrapper<_CharT>,
+                             _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+                             _STLP_PRIV __on_right> _STLP_CALL
+operator+(const _CharT* __s,
+          const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __y) {
+  const size_t __n = _Traits::length(__s);
+  return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __cstr_wrapper<_CharT>,
+                                                        _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+                                                        _STLP_PRIV __on_right>(_STLP_PRIV __cstr_wrapper<_CharT>(__s, __n), __y);
+}
+
+// addition with char
+template <class _CharT, class _Traits, class _Alloc>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+                             _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+                             _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+                                                   _STLP_PRIV __char_wrapper<_CharT>,
+                                                   _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+                                                   _STLP_PRIV __on_right>,
+                             _STLP_PRIV __on_right> _STLP_CALL
+operator+(const basic_string<_CharT,_Traits,_Alloc>& __x, const _CharT __c) {
+  typedef _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __char_wrapper<_CharT>,
+                                                         _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+                                                         _STLP_PRIV __on_right> __root_type;
+  __root_type __root(__c, _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>(__x.get_allocator()));
+  return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+                                                        __root_type, _STLP_PRIV __on_right>(__x, __root);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+                             _STLP_PRIV __char_wrapper<_CharT>,
+                             _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+                                                   _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+                                                   _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+                                                   _STLP_PRIV __on_right>,
+                             _STLP_PRIV __on_right> _STLP_CALL
+operator+(const _CharT __c, const basic_string<_CharT,_Traits,_Alloc>& __x) {
+  typedef _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+                                                         _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+                                                         _STLP_PRIV __on_right> __root_type;
+  __root_type __root(__x, _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>(__x.get_allocator()));
+  return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __char_wrapper<_CharT>,
+                                                        __root_type, _STLP_PRIV __on_right>(__c, __root);
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+                             _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+                             _STLP_PRIV __char_wrapper<_CharT>,
+                             _STLP_PRIV __on_left> _STLP_CALL
+operator+(const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __x, const _CharT __c) {
+  return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+                                                        _STLP_PRIV __char_wrapper<_CharT>, _STLP_PRIV __on_left>(__x, __c);
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __char_wrapper<_CharT>,
+                                                      _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+                                                      _STLP_PRIV __on_right> _STLP_CALL
+operator+(const _CharT __c, const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __x) {
+  return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __char_wrapper<_CharT>,
+                                                        _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+                                                        _STLP_PRIV __on_right>(__c, __x);
+}
+
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+// Operator== and operator!=
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator==(const basic_string<_CharT,_Traits,_Alloc>& __x,
+           const basic_string<_CharT,_Traits,_Alloc>& __y) {
+  return __x.size() == __y.size() && _Traits::compare(__x.data(), __y.data(), __x.size()) == 0;
+}
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator==(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
+           const basic_string<_CharT,_Traits,_Alloc>& __y) {
+  return __x.size() == __y.size() && _Traits::compare(__x.data(), __y.data(), __x.size()) == 0;
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator==(const basic_string<_CharT,_Traits,_Alloc>& __x,
+           const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
+  return __x.size() == __y.size() && _Traits::compare(__x.data(), __y.data(), __x.size()) == 0;
+}
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator==(const _CharT* __s,
+           const basic_string<_CharT,_Traits,_Alloc>& __y) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  size_t __n = _Traits::length(__s);
+  return __n == __y.size() && _Traits::compare(__s, __y.data(), __n) == 0;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator==(const basic_string<_CharT,_Traits,_Alloc>& __x,
+           const _CharT* __s) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  size_t __n = _Traits::length(__s);
+  return __x.size() == __n && _Traits::compare(__x.data(), __s, __n) == 0;
+}
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator==(const _CharT* __s,
+           const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  size_t __n = _Traits::length(__s);
+  return __n == __y.size() && _Traits::compare(__s, __y.data(), __n) == 0;
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator==(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
+           const _CharT* __s) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  size_t __n = _Traits::length(__s);
+  return __x.size() == __n && _Traits::compare(__x.data(), __s, __n) == 0;
+}
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+// Operator< (and also >, <=, and >=).
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator<(const basic_string<_CharT,_Traits,_Alloc>& __x,
+          const basic_string<_CharT,_Traits,_Alloc>& __y) {
+  return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__x.begin(), __x.end(),
+                                                          __y.begin(), __y.end()) < 0;
+}
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator<(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
+          const basic_string<_CharT,_Traits,_Alloc>& __y) {
+  return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__x.begin(), __x.end(),
+                                                          __y.begin(), __y.end()) < 0;
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator<(const basic_string<_CharT,_Traits,_Alloc>& __x,
+          const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
+  return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__x.begin(), __x.end(),
+                                                          __y.begin(), __y.end()) < 0;
+}
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator<(const _CharT* __s,
+          const basic_string<_CharT,_Traits,_Alloc>& __y) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  size_t __n = _Traits::length(__s);
+  return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__s, __s + __n,
+                                                          __y.begin(), __y.end()) < 0;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator<(const basic_string<_CharT,_Traits,_Alloc>& __x,
+          const _CharT* __s) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  size_t __n = _Traits::length(__s);
+  return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__x.begin(), __x.end(),
+                                                          __s, __s + __n) < 0;
+}
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator<(const _CharT* __s,
+          const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  size_t __n = _Traits::length(__s);
+  return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__s, __s + __n,
+                                                          __y.begin(), __y.end()) < 0;
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator<(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
+          const _CharT* __s) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  size_t __n = _Traits::length(__s);
+  return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__x.begin(), __x.end(),
+                                                          __s, __s + __n) < 0;
+}
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+#if defined (_STLP_USE_SEPARATE_RELOPS_NAMESPACE)
+
+/* Only defined if _STLP_USE_SEPARATE_RELOPS_NAMESPACE is defined otherwise
+ * it might introduce ambiguity with pure template relational operators
+ * from rel_ops namespace.
+ */
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator!=(const basic_string<_CharT,_Traits,_Alloc>& __x,
+           const basic_string<_CharT,_Traits,_Alloc>& __y)
+{ return !(__x == __y); }
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator>(const basic_string<_CharT,_Traits,_Alloc>& __x,
+          const basic_string<_CharT,_Traits,_Alloc>& __y)
+{ return __y < __x; }
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator<=(const basic_string<_CharT,_Traits,_Alloc>& __x,
+           const basic_string<_CharT,_Traits,_Alloc>& __y)
+{ return !(__y < __x); }
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator>=(const basic_string<_CharT,_Traits,_Alloc>& __x,
+           const basic_string<_CharT,_Traits,_Alloc>& __y)
+{ return !(__x < __y); }
+
+#  if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator!=(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
+           const basic_string<_CharT,_Traits,_Alloc>& __y)
+{ return !(__x==__y); }
+
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator!=(const basic_string<_CharT,_Traits,_Alloc>& __x,
+           const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y)
+{ return !(__x==__y); }
+#  endif
+
+#endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator!=(const _CharT* __s,
+           const basic_string<_CharT,_Traits,_Alloc>& __y) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  return !(__s == __y);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator!=(const basic_string<_CharT,_Traits,_Alloc>& __x,
+           const _CharT* __s) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  return !(__x == __s);
+}
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator!=(const _CharT* __s,
+           const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  return !(__s == __y);
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator!=(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
+           const _CharT* __s) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  return !(__x == __s);
+}
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator>(const _CharT* __s,
+          const basic_string<_CharT,_Traits,_Alloc>& __y) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  return __y < __s;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator>(const basic_string<_CharT,_Traits,_Alloc>& __x,
+          const _CharT* __s) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  return __s < __x;
+}
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator>(const _CharT* __s,
+          const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  return __y < __s;
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator>(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
+          const _CharT* __s) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  return __s < __x;
+}
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator<=(const _CharT* __s,
+           const basic_string<_CharT,_Traits,_Alloc>& __y) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  return !(__y < __s);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator<=(const basic_string<_CharT,_Traits,_Alloc>& __x,
+           const _CharT* __s) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  return !(__s < __x);
+}
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator<=(const _CharT* __s,
+           const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  return !(__y < __s);
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator<=(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
+           const _CharT* __s) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  return !(__s < __x);
+}
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator>=(const _CharT* __s,
+           const basic_string<_CharT,_Traits,_Alloc>& __y) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  return !(__s < __y);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator>=(const basic_string<_CharT,_Traits,_Alloc>& __x,
+           const _CharT* __s) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  return !(__x < __s);
+}
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator>=(const _CharT* __s,
+           const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  return !(__s < __y);
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator>=(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
+           const _CharT* __s) {
+  _STLP_FIX_LITERAL_BUG(__s)
+  return !(__x < __s);
+}
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_STRING_OPERATORS_H */
+
diff --git a/stlport/stlport/stl/_tempbuf.c b/stlport/stlport/stl/_tempbuf.c
new file mode 100644
index 0000000..179b472
--- /dev/null
+++ b/stlport/stlport/stl/_tempbuf.c
@@ -0,0 +1,57 @@
+/*
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_TEMPBUF_C
+#define _STLP_TEMPBUF_C
+
+#ifndef _STLP_INTERNAL_TEMPBUF_H
+# include <stl/_tempbuf.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _Tp>
+pair<_Tp*, ptrdiff_t> _STLP_CALL
+__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);
+}
+_STLP_END_NAMESPACE
+
+#endif /*  _STLP_TEMPBUF_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/_tempbuf.h b/stlport/stlport/stl/_tempbuf.h
new file mode 100644
index 0000000..0e0a747
--- /dev/null
+++ b/stlport/stlport/stl/_tempbuf.h
@@ -0,0 +1,167 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_TEMPBUF_H
+#define _STLP_INTERNAL_TEMPBUF_H
+
+#ifndef _STLP_CLIMITS
+#  include <climits>
+#endif
+
+#ifndef _STLP_INTERNAL_CSTDLIB
+#  include <stl/_cstdlib.h>
+#endif
+
+#ifndef _STLP_INTERNAL_UNINITIALIZED_H
+#  include <stl/_uninitialized.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _Tp>
+pair<_Tp*, ptrdiff_t>  _STLP_CALL
+__get_temporary_buffer(ptrdiff_t __len, _Tp*);
+
+#ifndef _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS
+
+template <class _Tp>
+inline pair<_Tp*, ptrdiff_t>  _STLP_CALL get_temporary_buffer(ptrdiff_t __len) {
+  return __get_temporary_buffer(__len, (_Tp*) 0);
+}
+
+# if ! defined(_STLP_NO_EXTENSIONS)
+// 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>  _STLP_CALL
+get_temporary_buffer(ptrdiff_t __len, _Tp*) {
+  return __get_temporary_buffer(__len, (_Tp*) 0);
+}
+# endif
+#endif
+
+template <class _Tp>
+inline void  _STLP_CALL return_temporary_buffer(_Tp* __p) {
+// SunPro brain damage
+  free((char*)__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&, const __true_type&) {}
+  void _M_initialize_buffer(const _Tp& val, const __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) {
+    // Workaround for a __type_traits bug in the pre-7.3 compiler.
+#   if defined(__sgi) && !defined(__GNUC__) && _COMPILER_VERSION < 730
+    typedef typename __type_traits<_Tp>::is_POD_type _Trivial;
+#   else
+    typedef typename __type_traits<_Tp>::has_trivial_default_constructor  _Trivial;
+#   endif
+    _STLP_TRY {
+      _M_len = _STLP_STD::distance(__first, __last);
+      _M_allocate_buffer();
+      if (_M_len > 0)
+        _M_initialize_buffer(*__first, _Trivial());
+    }
+    _STLP_UNWIND(free(_M_buffer); _M_buffer = 0; _M_len = 0)
+  }
+
+  ~_Temporary_buffer() {
+    _STLP_STD::_Destroy_Range(_M_buffer, _M_buffer + _M_len);
+    free(_M_buffer);
+  }
+
+private:
+  // Disable copy constructor and assignment operator.
+  _Temporary_buffer(const _Temporary_buffer<_ForwardIterator, _Tp>&) {}
+  void operator=(const _Temporary_buffer<_ForwardIterator, _Tp>&) {}
+};
+
+# ifndef _STLP_NO_EXTENSIONS
+
+// Class temporary_buffer is not part of the standard.  It is an extension.
+
+template <class _ForwardIterator,
+          class _Tp
+#ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
+                    = typename iterator_traits<_ForwardIterator>::value_type
+#endif /* _STLP_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() {}
+};
+
+# endif /* _STLP_NO_EXTENSIONS */
+
+_STLP_END_NAMESPACE
+
+# ifndef _STLP_LINK_TIME_INSTANTIATION
+#  include <stl/_tempbuf.c>
+# endif
+
+#endif /* _STLP_INTERNAL_TEMPBUF_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/char_traits.h b/stlport/stlport/stl/char_traits.h
new file mode 100644
index 0000000..f004a70
--- /dev/null
+++ b/stlport/stlport/stl/char_traits.h
@@ -0,0 +1,278 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CHAR_TRAITS_H
+#define _STLP_CHAR_TRAITS_H
+
+// Define char_traits
+
+#ifndef _STLP_INTERNAL_CSTDDEF
+#  include <stl/_cstddef.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CSTRING
+#  include <stl/_cstring.h>
+#endif
+
+#if defined (__unix)
+#  include <sys/types.h>         // For off_t
+#endif /* __unix */
+
+#if defined (__BORLANDC__)
+#  include <mem.h>
+#  include <string.h>
+#  include <_stddef.h>
+#  include <sys/types.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CONSTRUCT_H
+#  include <stl/_construct.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CWCHAR
+#  include <stl/_cwchar.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _Tp> class allocator;
+
+#define _STLP_NULL_CHAR_INIT(_ChT) _STLP_DEFAULT_CONSTRUCTED(_ChT)
+
+#if defined(_STLP_WCE)
+typedef long streamoff;
+#elif defined (_STLP_WIN32)
+#  if defined (_STLP_LONG_LONG) && !defined (__CYGWIN__)
+//The Win32 file io API support 64 bits access so streamoff and streamsize
+//has to reflect that. Do not change the stringbuf behavior.
+typedef _STLP_LONG_LONG streamoff;
+#  else
+typedef ptrdiff_t streamoff;
+#  endif
+#else // __unix
+#  ifdef _STLP_USE_DEFAULT_FILE_OFFSET
+typedef off_t streamoff;
+#  elif defined(_LARGEFILE_SOURCE) || defined(_LARGEFILE64_SOURCE) /* || defined(__USE_FILE_OFFSET64) */ \
+       /* || (defined(_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)) */ /* || defined (__sgi) && defined (_STLP_HAS_NO_NEW_C_HEADERS) */
+typedef off64_t streamoff;
+#  else
+typedef off_t streamoff;
+#  endif
+#endif /* __unix */
+
+#if defined (_STLP_WIN32)
+typedef streamoff streamsize;
+#else
+typedef ptrdiff_t streamsize;
+#endif
+
+// Class fpos, which represents a position within a file.  (The C++
+// standard calls for it to be defined in <ios>.  This implementation
+// moves it to <iosfwd>, which is included by <ios>.)
+template <class _StateT> class fpos {
+public:                         // From table 88 of the C++ standard.
+  fpos(streamoff __pos) : _M_pos(__pos), _M_st(_STLP_NULL_CHAR_INIT(_StateT)) {}
+  fpos() : _M_pos(0), _M_st(_STLP_NULL_CHAR_INIT(_StateT)) {}
+
+  operator streamoff() const { return _M_pos; }
+
+  bool operator==(const fpos& __y) const
+  { return _M_pos == __y._M_pos; }
+  bool operator!=(const fpos& __y) const
+  { return _M_pos != __y._M_pos; }
+
+  fpos& operator+=(streamoff __off) {
+    _M_pos += __off;
+    return *this;
+  }
+  fpos& operator-=(streamoff __off) {
+    _M_pos -= __off;
+    return *this;
+  }
+
+  fpos operator+(streamoff __off) {
+    fpos __tmp(*this);
+    __tmp += __off;
+    return __tmp;
+  }
+  fpos operator-(streamoff __off) {
+    fpos __tmp(*this);
+    __tmp -= __off;
+    return __tmp;
+  }
+
+public:                         // Manipulation of the state member.
+  _StateT state() const { return _M_st; }
+  void state(_StateT __st) { _M_st = __st; }
+private:
+  streamoff _M_pos;
+  _StateT _M_st;
+};
+
+typedef fpos<mbstate_t> streampos;
+typedef fpos<mbstate_t> wstreampos;
+
+// Class __char_traits_base.
+template <class _CharT, class _IntT>
+class __char_traits_base {
+public:
+  typedef _CharT char_type;
+  typedef _IntT int_type;
+  typedef streamoff off_type;
+  typedef streampos pos_type;
+  typedef mbstate_t state_type;
+
+  static void _STLP_CALL assign(char_type& __c1, const char_type& __c2) { __c1 = __c2; }
+  static bool _STLP_CALL eq(const char_type& __c1, const char_type& __c2)
+  { return __c1 == __c2; }
+  static bool _STLP_CALL lt(const char_type& __c1, const char_type& __c2)
+  { return __c1 < __c2; }
+
+  static int _STLP_CALL compare(const char_type* __s1, const char_type* __s2, size_t __n) {
+    for (size_t __i = 0; __i < __n; ++__i)
+      if (!eq(__s1[__i], __s2[__i]))
+        return __s1[__i] < __s2[__i] ? -1 : 1;
+    return 0;
+  }
+
+  static size_t _STLP_CALL length(const char_type* __s) {
+    const char_type _NullChar = _STLP_DEFAULT_CONSTRUCTED(char_type);
+    size_t __i(0);
+    for (; !eq(__s[__i], _NullChar); ++__i) {}
+    return __i;
+  }
+
+  static const char_type* _STLP_CALL find(const char_type* __s, size_t __n, const char_type& __c) {
+    for ( ; __n > 0 ; ++__s, --__n)
+      if (eq(*__s, __c))
+        return __s;
+    return 0;
+  }
+
+  static char_type* _STLP_CALL move(char_type* __s1, const char_type* __s2, size_t _Sz)
+  { return (_Sz == 0 ? __s1 : (char_type*)memmove(__s1, __s2, _Sz * sizeof(char_type))); }
+
+  static char_type* _STLP_CALL copy(char_type* __s1, const char_type* __s2, size_t __n) {
+    return (__n == 0 ? __s1 :
+      (char_type*)memcpy(__s1, __s2, __n * sizeof(char_type)));
+  }
+
+  static char_type* _STLP_CALL assign(char_type* __s, size_t __n, char_type __c) {
+    for (size_t __i = 0; __i < __n; ++__i)
+      __s[__i] = __c;
+    return __s;
+  }
+
+  static int_type _STLP_CALL not_eof(const int_type& __c)
+  { return !eq_int_type(__c, eof()) ? __c : __STATIC_CAST(int_type, 0); }
+
+  static char_type _STLP_CALL to_char_type(const int_type& __c)
+  { return (char_type)__c; }
+
+  static int_type _STLP_CALL to_int_type(const char_type& __c)
+  { return (int_type)__c; }
+
+  static bool _STLP_CALL eq_int_type(const int_type& __c1, const int_type& __c2)
+  { return __c1 == __c2; }
+
+  static int_type _STLP_CALL eof()
+  { return (int_type)-1; }
+};
+
+// Generic char_traits class.  Note that this class is provided only
+//  as a base for explicit specialization; it is unlikely to be useful
+//  as is for any particular user-defined type.  In particular, it
+//  *will not work* for a non-POD type.
+
+template <class _CharT>
+class char_traits
+  : public __char_traits_base<_CharT, _CharT> {};
+
+// Specialization for char.
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC char_traits<char>
+  : public __char_traits_base<char, int>,
+    public __stlport_class<char_traits<char> > {
+public:
+  typedef char char_type;
+  typedef int int_type;
+  typedef streamoff off_type;
+  typedef streampos pos_type;
+  typedef mbstate_t state_type;
+
+  static char _STLP_CALL to_char_type(const int& __c)
+  { return (char)(unsigned char)__c; }
+
+  static int _STLP_CALL to_int_type(const char& __c)
+  { return (unsigned char)__c; }
+
+  static int _STLP_CALL compare(const char* __s1, const char* __s2, size_t __n)
+  { return memcmp(__s1, __s2, __n); }
+
+  static size_t _STLP_CALL length(const char* __s)
+  { return strlen(__s); }
+
+  static void _STLP_CALL assign(char& __c1, const char& __c2)
+  { __c1 = __c2; }
+
+  static char* _STLP_CALL assign(char* __s, size_t __n, char __c) {
+    memset(__s, __c, __n);
+    return __s;
+  }
+};
+
+#if defined (_STLP_HAS_WCHAR_T)
+// Specialization for wchar_t.
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC char_traits<wchar_t>
+  : public __char_traits_base<wchar_t, wint_t> {
+#  if !defined (_STLP_NO_NATIVE_WIDE_FUNCTIONS) && !defined (_STLP_WCHAR_HPACC_EXCLUDE)
+public:
+#    if !defined (__BORLANDC__)
+  static wchar_t* _STLP_CALL move(wchar_t* __dest, const wchar_t* __src, size_t __n)
+  { return wmemmove(__dest, __src, __n); }
+#    endif
+
+  static wchar_t* _STLP_CALL copy(wchar_t* __dest, const wchar_t* __src, size_t __n)
+  { return wmemcpy(__dest, __src, __n); }
+
+#    if !defined (__DMC__) && !defined (__BORLANDC__)
+  static int _STLP_CALL compare(const wchar_t* __s1, const wchar_t* __s2, size_t __n)
+  { return wmemcmp(__s1, __s2, __n); }
+#    endif
+
+  static wchar_t* _STLP_CALL assign(wchar_t* __s, size_t __n, wchar_t __c)
+  { return wmemset(__s, __c, __n); }
+
+  static size_t _STLP_CALL length(const wchar_t* __s)
+  { return wcslen(__s); }
+
+  static void _STLP_CALL assign(wchar_t& __c1, const wchar_t& __c2)
+  { __c1 = __c2; }
+#  endif
+};
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_CHAR_TRAITS_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/stl/config/_auto_link.h b/stlport/stlport/stl/config/_auto_link.h
new file mode 100644
index 0000000..8898c55
--- /dev/null
+++ b/stlport/stlport/stl/config/_auto_link.h
@@ -0,0 +1,61 @@
+/* We do not use auto link feature when:
+ *  - user asked not to use it (_STLP_DONT_USE_AUTO_LINK)
+ *  - STLport is used only as a STL library (_STLP_NO_IOSTREAMS || _STLP_USE_NO_IOSTREAMS)
+ *  - we are building a C translation unit, STLport is a C++ Standard library implementation
+ */
+#if !defined (__BUILDING_STLPORT) && !defined (_STLP_DONT_USE_AUTO_LINK) && \
+    !defined (_STLP_NO_IOSTREAMS) && !defined (_STLP_USE_NO_IOSTREAMS) && \
+    defined (__cplusplus)
+
+#  define _STLP_STRINGIZE(X) _STLP_STRINGIZE_AUX(X)
+#  define _STLP_STRINGIZE_AUX(X) #X
+
+#  if defined (_STLP_DEBUG)
+#    define _STLP_LIB_OPTIM_MODE "stld"
+#  elif defined (_DEBUG)
+#    define _STLP_LIB_OPTIM_MODE "d"
+#  else
+#    define _STLP_LIB_OPTIM_MODE ""
+#  endif
+
+#  if defined (_STLP_LIB_NAME_MOTIF)
+#    define _STLP_LIB_MOTIF "_"_STLP_LIB_NAME_MOTIF
+#  else
+#    define _STLP_LIB_MOTIF ""
+#  endif
+
+#  if defined (_STLP_USE_DYNAMIC_LIB)
+#    if defined (_STLP_USING_CROSS_NATIVE_RUNTIME_LIB)
+#      define _STLP_LIB_TYPE "_x"
+#    else
+#      define _STLP_LIB_TYPE ""
+#    endif
+#  else
+#    if defined (_STLP_USING_CROSS_NATIVE_RUNTIME_LIB)
+#      define _STLP_LIB_TYPE "_statix"
+#    else
+#      define _STLP_LIB_TYPE "_static"
+#    endif
+#  endif
+
+#  if defined (_STLP_USE_DYNAMIC_LIB)
+#    define _STLP_VERSION_STR "."_STLP_STRINGIZE(_STLPORT_MAJOR)"."_STLP_STRINGIZE(_STLPORT_MINOR)
+#  else
+#    define _STLP_VERSION_STR ""
+#  endif
+
+#  define _STLP_STLPORT_LIB "stlport"_STLP_LIB_OPTIM_MODE""_STLP_LIB_TYPE""_STLP_LIB_MOTIF""_STLP_VERSION_STR".lib"
+
+#  if defined (_STLP_VERBOSE)
+#    pragma message ("STLport: Auto linking to "_STLP_STLPORT_LIB)
+#  endif
+#  pragma comment (lib, _STLP_STLPORT_LIB)
+
+#  undef _STLP_STLPORT_LIB
+#  undef _STLP_LIB_OPTIM_MODE
+#  undef _STLP_LIB_TYPE
+#  undef _STLP_STRINGIZE_AUX
+#  undef _STLP_STRINGIZE
+
+#endif /* _STLP_DONT_USE_AUTO_LINK */
+
diff --git a/stlport/stlport/stl/config/_detect_dll_or_lib.h b/stlport/stlport/stl/config/_detect_dll_or_lib.h
new file mode 100644
index 0000000..a062e69
--- /dev/null
+++ b/stlport/stlport/stl/config/_detect_dll_or_lib.h
@@ -0,0 +1,74 @@
+/* File used to define macros:
+ * _STLP_USE_DYNAMIC_LIB: To signal use STLport as a dll or build of the
+ *                        STLport dlls.
+ * _STLP_USE_STATIC_LIB: To signal use of STLport as a static lib or build of
+ *                       the STLport static libs.
+ * _STLP_USING_CROSS_NATIVE_RUNTIME_LIB: Signal that we are using a native runtime
+ *                                       in a version different from the STLport one.
+ * If _STLP_USE_DYNAMIC_LIB or _STLP_USE_STATIC_LIB is alreday defined it means that
+ * user forces use of a specific version. In this case _STLP_USING_CROSS_NATIVE_RUNTIME_LIB
+ * will surely be defined otherwise there is no need to force macro defines.
+ *
+ * Before including this file the compiler must define:
+ * _STLP_DLL: If we are building a dll
+ * _STLP_RUNTIME_DLL: If we are using native runtime as a dll
+ */
+#if defined (__BUILDING_STLPORT)
+#  undef _STLP_USE_DYNAMIC_LIB
+#  undef _STLP_USE_STATIC_LIB
+#  if defined (_STLP_DLL)
+/* We are building the STLport dll */
+#    define _STLP_USE_DYNAMIC_LIB
+#    if !defined (_STLP_RUNTIME_DLL)
+#      define _STLP_USING_CROSS_NATIVE_RUNTIME_LIB
+#    endif
+#  else
+#    define _STLP_USE_STATIC_LIB
+#    if defined (_STLP_RUNTIME_DLL)
+#      define _STLP_USING_CROSS_NATIVE_RUNTIME_LIB
+#    endif
+#  endif
+#else
+#  if !defined (_STLP_NO_IOSTREAMS)
+/* STLport use only depend on _STLP_RUNTIME_DLL as we are replacing
+ * the native runtime.
+ */
+#    if defined (_STLP_RUNTIME_DLL)
+#      if !defined (_STLP_USE_STATIC_LIB)
+#        if !defined (_STLP_USE_DYNAMIC_LIB)
+#          define _STLP_USE_DYNAMIC_LIB
+#        endif
+#      else
+/* The user is forcing use of STLport as a dynamic library. We signal it so
+ * that the STLport namespace will be modify to report such a combination
+ * and force the user to link with the rebuilt STLport library.
+ */
+#        define _STLP_USING_CROSS_NATIVE_RUNTIME_LIB
+#      endif
+#    else
+#      if !defined(_STLP_USE_DYNAMIC_LIB)
+#        if !defined (_STLP_USE_STATIC_LIB)
+#          define _STLP_USE_STATIC_LIB
+#        endif
+#      else
+/* Idem previous remark but the user forces use of the static native runtime.
+ */
+#        define _STLP_USING_CROSS_NATIVE_RUNTIME_LIB
+#      endif
+#    endif
+#  else
+/* If we do not build and use STLport libs we consider that we are in a static lib
+ * mode as only dynamic lib needs additional export/import specifier.
+ */
+#    define _STLP_USE_STATIC_LIB
+#  endif
+#endif
+
+/* we don't have a static native runtime library on evc3/evc4 */
+#ifdef _STLP_WCE
+#  undef _STLP_USING_CROSS_NATIVE_RUNTIME_LIB
+#endif
+
+#if !defined (_STLP_USE_DYNAMIC_LIB) && !defined (_STLP_USE_STATIC_LIB)
+#  error Unknown STLport usage config (dll/lib?)
+#endif
diff --git a/stlport/stlport/stl/config/_epilog.h b/stlport/stlport/stl/config/_epilog.h
new file mode 100644
index 0000000..30d1e24
--- /dev/null
+++ b/stlport/stlport/stl/config/_epilog.h
@@ -0,0 +1,29 @@
+#if defined (_STLP_MSVC) || defined (__ICL)
+
+#  pragma warning (pop)
+#  pragma pack (pop)
+
+#elif defined (__BORLANDC__)
+
+#  pragma option pop
+#  pragma option -w-pow     // -w-8062 Previous options and warnings not restored
+
+#elif defined (__sgi) && !defined (__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+
+#  pragma reset woff 1174
+#  pragma reset woff 1375
+#  pragma reset woff 1209
+/* from iterator_base.h */
+#  pragma reset woff 1183
+
+#elif defined (__DECCXX)
+
+#  ifdef __PRAGMA_ENVIRONMENT
+#    pragma __environment __restore
+#  endif
+
+#elif defined (__IBMCPP__)
+
+#  pragma info(restore)
+
+#endif
diff --git a/stlport/stlport/stl/config/_feedback.h b/stlport/stlport/stl/config/_feedback.h
new file mode 100644
index 0000000..0171ca5
--- /dev/null
+++ b/stlport/stlport/stl/config/_feedback.h
@@ -0,0 +1,43 @@
+/* Helper header to give feedback about build environment configuration
+ * thanks to #pragma message directives.
+ */
+
+#if defined (_STLP_VERBOSE)
+#  define _STLP_VERBOSE_MODE_SUPPORTED
+
+#  if defined (_STLP_COMPILER)
+#    pragma message (_STLP_COMPILER)
+#  endif
+
+#  if defined (_STLP_NO_RTTI)
+#    pragma message ("STLport: RTTI support         -> Disabled")
+#  else
+#    pragma message ("STLport: RTTI support         -> Enabled")
+#  endif
+
+#  if defined (_STLP_HAS_NO_EXCEPTIONS)
+#    pragma message ("STLport: Exception support    -> Disabled")
+#  else
+#    pragma message ("STLport: Exception support    -> Enabled")
+#  endif
+
+#  if defined (_STLP_THREADS)
+#    pragma message ("STLport: Threading model      -> Multi")
+#  else
+#    pragma message ("STLport: Threading model      -> Mono")
+#  endif
+
+#  if defined (_STLP_USE_DYNAMIC_LIB)
+#    pragma message ("STLport: Library model        -> Dynamic")
+#  else
+#    pragma message ("STLport: Library model        -> Static")
+#  endif
+
+#  if defined (_STLP_USING_CROSS_NATIVE_RUNTIME_LIB)
+#    if defined (_STLP_USE_DYNAMIC_LIB)
+#    pragma message ("STLport: Native library model -> Static")
+#    else
+#    pragma message ("STLport: Native library model -> Dynamic")
+#    endif
+#  endif
+#endif
diff --git a/stlport/stlport/stl/config/_msvc.h b/stlport/stlport/stl/config/_msvc.h
new file mode 100644
index 0000000..418d018
--- /dev/null
+++ b/stlport/stlport/stl/config/_msvc.h
@@ -0,0 +1,265 @@
+/* STLport configuration file
+ * It is internal STLport header - DO NOT include it directly
+ * Microsoft Visual C++ 6.0, 7.0, 7.1, 8.0, ICL
+ */
+
+#if !defined (_STLP_COMPILER)
+#  define _STLP_COMPILER "Microsoft Visual Studio C++"
+#endif
+
+#if !defined (__ICL) && !defined (_STLP_MSVC)
+#  define _STLP_MSVC _MSC_VER
+#endif
+
+#if !defined (_STLP_MSVC_LIB)
+#  define _STLP_MSVC_LIB _MSC_VER
+#endif
+
+#if defined (__BUILDING_STLPORT) && defined (_MANAGED)
+/* Building a managed version of STLport is not supported because we haven't
+ * found a good reason to support it. However, building a managed translation
+ * unit using STLport _is_ supported.
+ */
+#  error Sorry but building a managed version of STLport is not supported.
+#endif
+
+#if defined (_STLP_USING_PLATFORM_SDK_COMPILER)
+/* This is a specific section for compilers coming with platform SDKs. Native
+ * library coming with it is different from the one coming with commercial
+ * MSVC compilers so there is some specific settings.
+ */
+#  define _STLP_NATIVE_INCLUDE_PATH ../crt
+#  define _STLP_VENDOR_GLOBAL_CSTD
+#  define _STLP_VENDOR_TERMINATE_STD
+#  define _STLP_GLOBAL_NEW_HANDLER
+#  if (_STLP_MSVC_LIB <= 1400)
+/* We hope this bug will be fixed in future versions. */
+#    define _STLP_NEW_DONT_THROW_BAD_ALLOC 1
+#  endif
+#endif
+
+#define _STLP_CALL __cdecl
+
+#ifndef _STLP_LONG_LONG
+#  define _STLP_LONG_LONG __int64
+#endif
+
+#define _STLP_PRAGMA_ONCE
+
+/* These switches depend on compiler flags. We are hoping here that compilers
+ * simulating MSVC behavior use identical macros to report compilation context.
+ * Otherwise those macros will have to be undef in specific compiler configuration
+ * files.
+ */
+#ifndef _CPPUNWIND
+#  define _STLP_DONT_USE_EXCEPTIONS 1
+#endif
+
+#ifndef _CPPRTTI
+#  define _STLP_NO_RTTI 1
+#endif
+
+#if defined (_MT) && !defined (_STLP_NO_THREADS)
+#  define _STLP_THREADS 1
+#endif
+
+#if !defined (_NATIVE_WCHAR_T_DEFINED)
+#  define _STLP_WCHAR_T_IS_USHORT 1
+#endif
+
+#define _STLP_NO_VENDOR_STDLIB_L 1
+
+#if defined (_STLP_MSVC)
+
+#  if (_STLP_MSVC < 1200)
+#    error Microsoft Visual C++ compilers before version 6 (SP5) are not supported.
+#  endif
+
+#  define _STLP_NORETURN_FUNCTION __declspec(noreturn)
+
+/* Full compiler version comes from boost library intrinsics.hpp header. */
+#  if defined (_MSC_FULL_VER) && (_MSC_FULL_VER >= 140050215)
+#    define _STLP_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
+#    define _STLP_HAS_TRIVIAL_COPY(T) __has_trivial_copy(T)
+#    define _STLP_HAS_TRIVIAL_ASSIGN(T) __has_trivial_assign(T)
+#    define _STLP_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T)
+#    define _STLP_IS_POD(T) __is_pod(T)
+#    define _STLP_HAS_TYPE_TRAITS_INTRINSICS
+#  endif
+
+#  ifndef _STLP_MSVC50_COMPATIBILITY
+#    define _STLP_MSVC50_COMPATIBILITY   1
+#  endif
+
+#  define _STLP_DLLEXPORT_NEEDS_PREDECLARATION 1
+#  define _STLP_HAS_SPECIFIC_PROLOG_EPILOG 1
+#  define _STLP_NO_STATIC_CONST_DEFINITION 1
+
+/* # ifndef __BUILDING_STLPORT
+ * #  define _STLP_USE_TEMPLATE_EXPORT 1
+ * # endif
+ */
+
+/** Note: the macro _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT is defined
+unconditionally and undef'ed here when applicable. */
+#  if defined (UNDER_CE)
+/* eVCx:
+uncaught_exception is declared in the SDKs delivered with eVC4 (eVC3 is
+unknown) and they all reside in namespace 'std' there. However, they are not
+part of any lib so linking fails. When using VC8 to crosscompile for CE 5 on
+an ARMV4I, the uncaught_exception test fails, the function returns the wrong
+value. */
+/* All eVCs up to at least VC8/CE5 have a broken new operator that
+   returns null instead of throwing bad_alloc. */
+#    define _STLP_NEW_DONT_THROW_BAD_ALLOC 1
+#  else
+/* VCx:
+These are present at least since VC6, but the uncaught_exception() of VC6 is
+broken, it returns the wrong value in the unittests. 7.1 and later seem to
+work, 7.0 is still unknown (we assume it works until negative report). */
+#    if (_STLP_MSVC >= 1300)// VC7 and later
+#      undef _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT
+#    endif
+#    if (_STLP_MSVC < 1300)
+#      define _STLP_NOTHROW
+#    endif
+#  endif
+
+#  if (_STLP_MSVC <= 1300)
+#    define _STLP_STATIC_CONST_INIT_BUG   1
+#    define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1
+#    define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1
+/* There is no partial spec, and MSVC breaks on simulating it for iterator_traits queries */
+#    define _STLP_USE_OLD_HP_ITERATOR_QUERIES
+#    define _STLP_NO_TYPENAME_IN_TEMPLATE_HEADER
+#    define _STLP_NO_METHOD_SPECIALIZATION 1
+#    define _STLP_DEF_CONST_PLCT_NEW_BUG 1
+#    define _STLP_NO_TYPENAME_ON_RETURN_TYPE 1
+/* VC++ cannot handle default allocator argument in template constructors */
+#    define _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS
+#    define _STLP_NO_QUALIFIED_FRIENDS    1
+#  endif
+
+#  if (_STLP_MSVC < 1300) /* including MSVC 6.0 */
+#    define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1
+#    define _STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE 1
+#  endif
+
+#  define _STLP_HAS_NATIVE_FLOAT_ABS 1
+
+// TODO: some eVC4 compilers report _MSC_VER 1201 or 1202, which category do they belong to?
+#  if (_STLP_MSVC > 1200) && (_STLP_MSVC < 1310)
+#    define _STLP_NO_MOVE_SEMANTIC
+#  endif
+
+#  if (_STLP_MSVC < 1300)
+/* TODO: remove this if it is handled and documented elsewhere
+ * dums: VC6 do not handle correctly member templates of class that are explicitely
+ * instanciated to be exported. There is a workaround, seperate the non template methods
+ * from the template ones within 2 different classes and only export the non template one.
+ * It is implemented for basic_string and locale at the writing of this note.
+ * However this problem hos not  been considered as important enough to remove template member
+ * methods for other classes. Moreover Boost (www.boost.org) required it to be granted.
+ * The workaround is activated thanks to the _STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND macro defined
+ * later in this config file.
+ */
+/*
+#    if defined (_DLL)
+#      define _STLP_NO_MEMBER_TEMPLATES 1
+#    endif
+*/
+
+/* Boris : not defining this macro for SP5 causes other problems */
+/*#    if !defined (_MSC_FULL_VER) || (_MSC_FULL_VER < 12008804 ) */
+#    define _STLP_NO_USING_FOR_GLOBAL_FUNCTIONS 1
+/*#    endif */
+#    define _STLP_DONT_USE_BOOL_TYPEDEF 1
+#    define _STLP_DONT_RETURN_VOID 1
+#  endif
+
+#  if (_STLP_MSVC < 1300) /* MSVC 6.0 and earlier */
+#    define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 1
+/* defined for DEBUG and NDEBUG too, to allow user mix own debug build with STLP release library */
+#    define _STLP_USE_ABBREVS
+#  endif
+
+#endif /* _STLP_MSVC */
+
+/* The desktop variants starting with VC8 have a set of more secure replacements
+ * for the error-prone string handling functions of the C standard lib. */
+/* When user do not consider 'unsafe' string functions as deprecated using _CRT_SECURE_NO_DEPRECATE
+ * macro we use 'unsafe' functions for performance reasons. */
+#if (_STLP_MSVC_LIB >= 1400) && !defined (_STLP_USING_PLATFORM_SDK_COMPILER) && !defined (UNDER_CE) && \
+    !defined (_CRT_SECURE_NO_DEPRECATE)
+#  define _STLP_USE_SAFE_STRING_FUNCTIONS 1
+#endif
+
+#if (_STLP_MSVC_LIB <= 1310)
+#  define _STLP_VENDOR_GLOBAL_CSTD
+#endif
+
+#if (_STLP_MSVC_LIB >= 1300) && !defined(UNDER_CE)
+/* Starting with MSVC 7.0 and compilers simulating it,
+ * we assume that the new SDK is granted:
+ */
+#  define _STLP_NEW_PLATFORM_SDK 1
+#endif
+
+#if (_STLP_MSVC_LIB < 1300) /* including MSVC 6.0 */
+#  define _STLP_GLOBAL_NEW_HANDLER 1
+#  define _STLP_VENDOR_UNEXPECTED_STD
+#  define _STLP_NEW_DONT_THROW_BAD_ALLOC 1
+#endif
+
+#define _STLP_EXPORT_DECLSPEC __declspec(dllexport)
+#define _STLP_IMPORT_DECLSPEC __declspec(dllimport)
+#define _STLP_CLASS_EXPORT_DECLSPEC __declspec(dllexport)
+#define _STLP_CLASS_IMPORT_DECLSPEC __declspec(dllimport)
+
+#if defined (__DLL) || defined (_DLL) || defined (_RTLDLL) || defined (_AFXDLL)
+#  define _STLP_RUNTIME_DLL
+#endif
+#if defined (__BUILDING_STLPORT) && \
+   (defined (_STLP_USE_DYNAMIC_LIB) || \
+    defined (_STLP_RUNTIME_DLL) && !defined (_STLP_USE_STATIC_LIB))
+#  define _STLP_DLL
+#endif
+#include <stl/config/_detect_dll_or_lib.h>
+#undef _STLP_RUNTIME_DLL
+#undef _STLP_DLL
+
+#if defined (_STLP_USE_DYNAMIC_LIB)
+#  undef  _STLP_USE_DECLSPEC
+#  define _STLP_USE_DECLSPEC 1
+#  if defined (_STLP_MSVC) && (_STLP_MSVC < 1300)
+#    define _STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND 1
+#  endif
+#endif
+
+#if !defined (_STLP_IMPORT_TEMPLATE_KEYWORD)
+#  if !defined (_MSC_EXTENSIONS) || defined (_STLP_MSVC) && (_STLP_MSVC >= 1300)
+#    define _STLP_IMPORT_TEMPLATE_KEYWORD
+#  else
+#    define _STLP_IMPORT_TEMPLATE_KEYWORD extern
+#  endif
+#endif
+#define _STLP_EXPORT_TEMPLATE_KEYWORD
+
+#include <stl/config/_auto_link.h>
+
+#if defined (_STLP_USING_PLATFORM_SDK_COMPILER)
+/* The Windows 64 bits SDK required for the moment link to bufferoverflowU.lib for
+ * additional buffer overrun checks. Rather than require the STLport build system and
+ * users to explicitely link with it we use the MSVC auto link feature.
+ */
+#  if !defined (_STLP_DONT_USE_AUTO_LINK) || defined (__BUILDING_STLPORT)
+#    pragma comment (lib, "bufferoverflowU.lib")
+#    if defined (_STLP_VERBOSE)
+#      pragma message ("STLport: Auto linking to bufferoverflowU.lib")
+#    endif
+#  endif
+#endif
+
+#if defined (_STLP_MSVC)
+#  include <stl/config/_feedback.h>
+#endif
diff --git a/stlport/stlport/stl/config/_native_headers.h b/stlport/stlport/stl/config/_native_headers.h
new file mode 100644
index 0000000..f1f4bc9
--- /dev/null
+++ b/stlport/stlport/stl/config/_native_headers.h
@@ -0,0 +1,50 @@
+ /*
+  *
+  * Copyright (c) 2006
+  * Francois Dumont
+  *
+  * This material is provided "as is", with absolutely no warranty expressed
+  * or implied. Any use is at your own risk.
+  *
+  * Permission to use or copy this software for any purpose is hereby granted
+  * without fee, provided the above notices are retained on all copies.
+  * Permission to modify the code and to distribute modified code is granted,
+  * provided the above notices are retained, and a notice that the code was
+  * modified is included with the above copyright notice.
+  *
+  */
+
+#if !defined (_STLP_MAKE_HEADER)
+#  define _STLP_MAKE_HEADER(path, header) <path/header>
+#endif
+
+#if !defined (_STLP_NATIVE_HEADER)
+#  if !defined (_STLP_NATIVE_INCLUDE_PATH)
+#    define _STLP_NATIVE_INCLUDE_PATH ../include
+#  endif
+#  define _STLP_NATIVE_HEADER(header) _STLP_MAKE_HEADER(_STLP_NATIVE_INCLUDE_PATH,header)
+#endif
+
+/* For some compilers, C headers like <stdio.h> are located in separate directory */
+#if !defined (_STLP_NATIVE_C_HEADER)
+#  if !defined (_STLP_NATIVE_C_INCLUDE_PATH)
+#    define _STLP_NATIVE_C_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH
+#  endif
+#  define _STLP_NATIVE_C_HEADER(header)  _STLP_MAKE_HEADER(_STLP_NATIVE_C_INCLUDE_PATH,header)
+#endif
+
+/* For some compilers, C-library headers like <cstdio> are located in separate directory */
+#if !defined (_STLP_NATIVE_CPP_C_HEADER)
+#  if !defined (_STLP_NATIVE_CPP_C_INCLUDE_PATH)
+#    define _STLP_NATIVE_CPP_C_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH
+#  endif
+#  define _STLP_NATIVE_CPP_C_HEADER(header)  _STLP_MAKE_HEADER(_STLP_NATIVE_CPP_C_INCLUDE_PATH,header)
+#endif
+
+/* Some compilers locate basic C++ runtime support headers (<new>, <typeinfo>, <exception>) in separate directory */
+#if !defined ( _STLP_NATIVE_CPP_RUNTIME_HEADER )
+#  if !defined (_STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH)
+#    define _STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH
+#  endif
+#  define _STLP_NATIVE_CPP_RUNTIME_HEADER(header)  _STLP_MAKE_HEADER(_STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH,header)
+#endif
diff --git a/stlport/stlport/stl/config/_prolog.h b/stlport/stlport/stl/config/_prolog.h
new file mode 100644
index 0000000..a16a794
--- /dev/null
+++ b/stlport/stlport/stl/config/_prolog.h
@@ -0,0 +1,43 @@
+
+#if defined (_STLP_MSVC) || defined (__ICL)
+
+#  pragma warning (push)
+#  include <stl/config/_warnings_off.h>
+/* We are forcing the alignment to guaranty that libraries are use
+ * with the same alignment as the one use to build them.
+ */
+#  if !defined (_WIN64)
+#    pragma pack(push, 8)
+#  else
+#    pragma pack(push, 16)
+#  endif
+
+#elif defined (__BORLANDC__)
+
+#  pragma option push
+#  pragma option -Vx- -Ve- -a8 -b -pc
+#  include <stl/config/_warnings_off.h>
+
+#elif defined (__sgi) && !defined (__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+
+#  pragma set woff 1209
+#  pragma set woff 1174
+#  pragma set woff 1375
+/* from iterator_base.h */
+#  pragma set woff 1183
+
+#elif defined (__DECCXX)
+
+#  ifdef __PRAGMA_ENVIRONMENT
+#    pragma __environment __save
+#    pragma __environment __header_defaults
+#  endif
+
+#elif defined (__IBMCPP__)
+/* supress EDC3130: A constant is being used as a conditional expression */
+#  pragma info(nocnd)
+#elif defined (__WATCOMCPLUSPLUS__)
+#  pragma warning 604 10 /* must lookahead to determine... */
+#  pragma warning 594 10 /* resolved as declaration/type */
+#  pragma warning 595 10 /* resolved as an expression */
+#endif
diff --git a/stlport/stlport/stl/config/_warnings_off.h b/stlport/stlport/stl/config/_warnings_off.h
new file mode 100644
index 0000000..77e9815
--- /dev/null
+++ b/stlport/stlport/stl/config/_warnings_off.h
@@ -0,0 +1,51 @@
+/* This header turns off warnings that STLport headers generate for compiled
+ * user code.
+ */
+
+#if defined (_STLP_MSVC)
+#  if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) || \
+      defined (_STLP_SIGNAL_RUNTIME_COMPATIBILITY) || defined (_STLP_CHECK_RUNTIME_COMPATIBILITY)
+/*
+ * 31/07/2004: dums - now that we do not export the basic_string class anymore but only a base class
+ * we have to disable this warning as the string are used as data members type of many iostream classes.
+ */
+#    pragma warning ( disable : 4251 )  // ignore template classes being exported in .dll's
+#  endif
+
+#  if (_STLP_MSVC < 1300) // VC6, eVC3, eVC4
+#    pragma warning( disable : 4097 ) // typedef-name used as based class of (...)
+#    pragma warning( disable : 4231 ) // non standard extension : 'extern' before template instanciation
+#    pragma warning( disable : 4244 ) // implicit conversion: possible loss of data
+#    pragma warning( disable : 4284 ) // for -> operator
+//This warning is necessary because of the native platform headers:
+#    pragma warning( disable : 4290 ) // c++ exception specification ignored
+#    pragma warning( disable : 4514 ) // unreferenced inline function has been removed
+#    pragma warning( disable : 4660 ) // template-class specialization '...' is already instantiated
+#    pragma warning( disable : 4701 ) // local variable '...' may be used without having been initialized
+#    pragma warning( disable : 4710 ) // function (...) not inlined
+#    pragma warning( disable : 4786 ) // identifier truncated to 255 characters
+#  endif
+
+#  if (_STLP_MSVC < 1400)
+#    pragma warning( disable : 4511 ) // copy constructor cannot be generated
+#  endif
+
+//Pool of common warnings for all MSVC supported versions:
+//Many are only useful if warning level is set to 4.
+#  pragma warning( disable : 4100 ) // unreferenced formal parameter
+#  pragma warning( disable : 4127 ) // conditional expression is constant
+#  pragma warning( disable : 4146 ) // unary minus operator applied to unsigned type, result still unsigned
+#  pragma warning( disable : 4245 ) // conversion from 'enum ' to 'unsigned int', signed/unsigned mismatch
+#  pragma warning( disable : 4355 ) // this used in base member initializer list (used in rope implementation)
+#  pragma warning( disable : 4510 ) // default constructor cannot be generated
+#  pragma warning( disable : 4512 ) // assignment operator could not be generated
+#  pragma warning( disable : 4571 ) // catch(...) blocks compiled with /EHs do not catch or re-throw Structured Exceptions
+#  pragma warning( disable : 4610 ) // struct '...' can never be instantiated - user defined construtor required
+#elif defined (__BORLANDC__)
+#  pragma option -w-ccc // -w-8008 Condition is always true OR Condition is always false
+#  pragma option -w-inl // -w-8027 Functions containing reserved words are not expanded inline
+#  pragma option -w-ngu // -w-8041 Negating unsigned value
+#  pragma option -w-pow // -w-8062 Previous options and warnings not restored
+#  pragma option -w-rch // -w-8066 Unreachable code
+#  pragma option -w-par // -w-8057 Parameter 'parameter' is never used
+#endif
diff --git a/stlport/stlport/stl/config/_windows.h b/stlport/stlport/stl/config/_windows.h
new file mode 100644
index 0000000..6b42e11
--- /dev/null
+++ b/stlport/stlport/stl/config/_windows.h
@@ -0,0 +1,291 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_INTERNAL_WINDOWS_H
+#define _STLP_INTERNAL_WINDOWS_H
+
+#if !defined (_STLP_PLATFORM)
+#  define _STLP_PLATFORM "Windows"
+#endif
+
+#if !defined (_STLP_BIG_ENDIAN) && !defined (_STLP_LITTLE_ENDIAN)
+#  if defined (_MIPSEB)
+#    define _STLP_BIG_ENDIAN 1
+#  endif
+#  if defined (__i386) || defined (_M_IX86) || defined (_M_ARM) || \
+      defined (__amd64__) || defined (_M_AMD64) || defined (__x86_64__) || \
+      defined (__alpha__)
+#    define _STLP_LITTLE_ENDIAN 1
+#  endif
+#  if defined (__ia64__)
+    /* itanium allows both settings (for instance via gcc -mbig-endian) - hence a seperate check is required */
+#    if defined (__BIG_ENDIAN__)
+#      define _STLP_BIG_ENDIAN 1
+#    else
+#      define _STLP_LITTLE_ENDIAN 1
+#    endif
+#  endif
+#endif /* _STLP_BIG_ENDIAN */
+
+#if !defined (_STLP_WINDOWS_H_INCLUDED)
+#  define _STLP_WINDOWS_H_INCLUDED
+#  if defined (__BUILDING_STLPORT)
+#    include <stl/config/_native_headers.h>
+/* Here we define _STLP_OUTERMOST_HEADER_ID to avoid indirect inclusion
+ * of STLport stuffs from C/C++ Standard headers exposed by STLport
+ * as configuration is not yet completed. */
+#    if !defined (_STLP_OUTERMOST_HEADER_ID)
+#      define _STLP_OUTERMOST_HEADER_ID 0x100
+#    endif
+#    if !defined (WIN32_LEAN_AND_MEAN)
+#      define WIN32_LEAN_AND_MEAN
+#    endif
+#    if !defined (VC_EXTRALEAN)
+#      define VC_EXTRALEAN
+#    endif
+/* Don't let windows.h define its min and max macros. */
+#    if !defined (NOMINMAX)
+#      define NOMINMAX
+#    endif
+#    if !defined (STRICT)
+#      define STRICT
+#    endif
+#    if defined (_STLP_USE_MFC)
+#      include <afx.h>
+#    else
+#      include <windows.h>
+#    endif
+#    if (_STLP_OUTERMOST_HEADER_ID == 0x100)
+#      undef _STLP_OUTERMOST_HEADER_ID
+#    endif
+#  else
+/* This section serves as a replacement for windows.h header. */
+#    if defined (__cplusplus)
+extern "C" {
+#    endif
+#    if (defined (_M_AMD64) || defined (_M_IA64) || (!defined (_STLP_WCE) && defined (_M_MRX000)) || defined (_M_ALPHA) || \
+        (defined (_M_PPC) && (_STLP_MSVC_LIB >= 1000))) && !defined (RC_INVOKED)
+#      define InterlockedIncrement       _InterlockedIncrement
+#      define InterlockedDecrement       _InterlockedDecrement
+#      define InterlockedExchange        _InterlockedExchange
+#      define _STLP_STDCALL
+#    else
+#      if defined (_MAC)
+#        define _STLP_STDCALL _cdecl
+#      else
+#        define _STLP_STDCALL __stdcall
+#      endif
+#    endif
+
+#    if defined (_STLP_NEW_PLATFORM_SDK)
+_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedIncrement(long volatile *);
+_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedDecrement(long volatile *);
+_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedExchange(long volatile *, long);
+#      if defined (_WIN64)
+_STLP_IMPORT_DECLSPEC void* _STLP_STDCALL _InterlockedExchangePointer(void* volatile *, void*);
+#      endif
+#    elif !defined (_STLP_WCE)
+/* boris : for the latest SDK, you may actually need the other version of the declaration (above)
+ * even for earlier VC++ versions. There is no way to tell SDK versions apart, sorry ...
+ */
+_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedIncrement(long*);
+_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedDecrement(long*);
+_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedExchange(long*, long);
+#    else
+/* start of eMbedded Visual C++ specific section */
+#      include <stl/config/_native_headers.h>
+
+/* Don't let windef.h define its min and max macros. */
+#      if !defined (NOMINMAX)
+#        define NOMINMAX
+#      endif
+#      include <windef.h> /* needed for basic windows types */
+
+       /** in SDKs generated with PB5, windef.h somehow includes headers which then
+       define setjmp. */
+#      if (_WIN32_WCE >= 0x500)
+#        define _STLP_NATIVE_SETJMP_H_INCLUDED
+#      endif
+
+#      ifndef _WINBASE_ /* winbase.h already included? */
+long WINAPI InterlockedIncrement(long*);
+long WINAPI InterlockedDecrement(long*);
+long WINAPI InterlockedExchange(long*, long);
+#      endif
+
+#      ifndef __WINDOWS__ /* windows.h already included? */
+
+#        if defined (x86)
+#          include <winbase.h> /* needed for inline versions of Interlocked* functions */
+#        endif
+
+#        ifndef _MFC_VER
+
+#          define MessageBox MessageBoxW
+int WINAPI MessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType);
+
+#          define wvsprintf wvsprintfW
+int WINAPI wvsprintfW(LPWSTR, LPCWSTR, va_list ArgList);
+
+void WINAPI ExitThread(DWORD dwExitCode);
+
+#          if !defined (COREDLL)
+#            define _STLP_WCE_WINBASEAPI DECLSPEC_IMPORT
+#          else
+#            define _STLP_WCE_WINBASEAPI
+#          endif
+
+_STLP_WCE_WINBASEAPI int WINAPI
+MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr,
+                    int cbMultiByte, LPWSTR lpWideCharStr, int cchWideChar);
+
+_STLP_WCE_WINBASEAPI UINT WINAPI GetACP();
+
+_STLP_WCE_WINBASEAPI BOOL WINAPI TerminateProcess(HANDLE hProcess, DWORD uExitCode);
+
+#          define OutputDebugString OutputDebugStringW
+void WINAPI OutputDebugStringW(LPCWSTR);
+
+_STLP_WCE_WINBASEAPI void WINAPI Sleep(DWORD);
+
+#          undef _STLP_WCE_WINBASEAPI
+
+#        endif /* !_MFC_VER */
+
+#      endif /* !__WINDOWS__ */
+
+/* end of eMbedded Visual C++ specific section */
+#    endif
+
+#    if !defined (_STLP_WCE)
+_STLP_IMPORT_DECLSPEC void _STLP_STDCALL Sleep(unsigned long);
+_STLP_IMPORT_DECLSPEC void _STLP_STDCALL OutputDebugStringA(const char* lpOutputString);
+#    endif
+
+#    if defined (InterlockedIncrement)
+#      pragma intrinsic(_InterlockedIncrement)
+#      pragma intrinsic(_InterlockedDecrement)
+#      pragma intrinsic(_InterlockedExchange)
+#      if defined (_WIN64)
+#        pragma intrinsic(_InterlockedExchangePointer)
+#      endif
+#    endif
+#    if defined (__cplusplus)
+} /* extern "C" */
+#    endif
+
+#  endif
+
+/* Here we use a macro different than the InterlockedExchangePointer SDK one
+ * to avoid macro definition conflict. */
+#  if !defined (_WIN64)
+/* Under 32 bits platform we rely on a simple InterlockedExchange call. */
+#    if defined (__cplusplus)
+/* We do not define this function if we are not in a C++ translation unit just
+ * because of the 'inline' keyword portability issue it would introduce. We will
+ * have to fix it the day we need this function for a C translation unit.
+ */
+inline
+void* _STLP_CALL STLPInterlockedExchangePointer(void* volatile* __a, void* __b) {
+#      if defined (_STLP_MSVC)
+/* Here MSVC produces warning if 64 bits portability issue is activated.
+ * MSVC do not see that _STLP_ATOMIC_EXCHANGE_PTR is a macro which content
+ * is based on the platform, Win32 or Win64
+ */
+#        pragma warning (push)
+#        pragma warning (disable : 4311) // pointer truncation from void* to long
+#        pragma warning (disable : 4312) // conversion from long to void* of greater size
+#      endif
+#      if !defined (_STLP_NO_NEW_STYLE_CASTS)
+  return reinterpret_cast<void*>(InterlockedExchange(reinterpret_cast<long*>(const_cast<void**>(__a)),
+                                                     reinterpret_cast<long>(__b)));
+#      else
+  return (void*)InterlockedExchange((long*)__a, (long)__b);
+#      endif
+#      if defined (_STLP_MSVC)
+#        pragma warning (pop)
+#      endif
+}
+#    endif
+#  else
+#    define STLPInterlockedExchangePointer _InterlockedExchangePointer
+#  endif
+
+#endif /* _STLP_WINDOWS_H_INCLUDED */
+
+/* _STLP_WIN95_LIKE signal the Windows 95 OS or assimilated Windows OS version that
+ * has Interlockeded[Increment, Decrement] Win32 API functions not returning modified
+ * value.
+ */
+#if (defined (WINVER) && (WINVER < 0x0410) && (!defined (_WIN32_WINNT) || (_WIN32_WINNT < 0x400))) || \
+    (!defined (WINVER) && (defined (_WIN32_WINDOWS) && (_WIN32_WINDOWS < 0x0410) || \
+                          (defined (_WIN32_WINNT) && (_WIN32_WINNT < 0x400))))
+#  define _STLP_WIN95_LIKE
+#endif
+
+/* Between Windows 95 (0x400) and later Windows OSes an API enhancement forces us
+ * to change _Refcount_Base internal struct. As _Refcount_base member methods might
+ * be partially inlined we need to check that STLport build/use are coherent. To do
+ * so we try to generate a link time error thanks to the following macro.
+ * This additional check is limited to old compilers that might still be used with
+ * Windows 95. */
+#if (defined (_DEBUG) || defined (_STLP_DEBUG)) && \
+    (defined (_STLP_MSVC) && (_STLP_MSVC < 1310) || \
+     defined (__GNUC__) && (__GNUC__ < 3))
+/* We invert symbol names based on macro detection, when building for Windows
+ * 95 we expose a
+ * building_for_windows95_or_previous_but_library_built_for_windows98_or_later
+ * function in order to have a more obvious link error message signaling how
+ * the lib has been built and how it is used. */
+#  if defined (__BUILDING_STLPORT)
+#    if defined (_STLP_WIN95_LIKE)
+#      define _STLP_SIGNAL_RUNTIME_COMPATIBILITY building_for_windows95_but_library_built_for_at_least_windows98
+#    else
+#      define _STLP_SIGNAL_RUNTIME_COMPATIBILITY building_for_at_least_windows98_but_library_built_for_windows95
+#    endif
+#  else
+#    if defined (_STLP_WIN95_LIKE)
+#      define _STLP_CHECK_RUNTIME_COMPATIBILITY building_for_windows95_but_library_built_for_at_least_windows98
+#    else
+#      define _STLP_CHECK_RUNTIME_COMPATIBILITY building_for_at_least_windows98_but_library_built_for_windows95
+#    endif
+#  endif
+#endif
+
+#if defined (__WIN16) || defined (WIN16) || defined (_WIN16)
+#  define _STLP_WIN16
+#else
+#  define _STLP_WIN32
+#endif
+
+#if defined(_STLP_WIN32)
+#  define _STLP_USE_WIN32_IO /* CreateFile/ReadFile/WriteFile */
+#endif
+
+#if defined(__MINGW32__) && !defined(_STLP_USE_STDIO_IO)
+#  define _STLP_USE_WIN32_IO /* CreateFile/ReadFile/WriteFile */
+#endif /* __MINGW32__ */
+
+#ifdef _STLP_WIN16
+#  define _STLP_USE_UNIX_EMULATION_IO /* _open/_read/_write */
+#  define _STLP_LDOUBLE_80
+#endif
+
+#endif /* _STLP_INTERNAL_WINDOWS_H */
diff --git a/stlport/stlport/string b/stlport/stlport/string
new file mode 100644
index 0000000..74d4589
--- /dev/null
+++ b/stlport/stlport/string
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_STRING
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+#  define _STLP_OUTERMOST_HEADER_ID 0x68
+#  include <stl/_prolog.h>
+#  define _STLP_STRING
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x68)
+#  ifndef _STLP_INTERNAL_STRING_H
+#    include <stl/_string.h>
+#  endif
+
+#  ifndef _STLP_STRING_HASH_H
+#    include <stl/_string_hash.h>
+#  endif
+
+#  if !defined (_STLP_USE_NO_IOSTREAMS) && !defined (_STLP_STRING_IO_H)
+#    include <stl/_string_io.h>
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x68) || defined (_STLP_IMPORT_VENDOR_STD)
+#  if defined (_STLP_HAS_INCLUDE_NEXT)
+#    include_next <string>
+#  else
+#    include _STLP_NATIVE_HEADER(string)
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x68)
+#  include <stl/_epilog.h>
+#  undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_STRING */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/stlport/stlport/utility b/stlport/stlport/utility
new file mode 100644
index 0000000..4aaaa59
--- /dev/null
+++ b/stlport/stlport/utility
@@ -0,0 +1,60 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_UTILITY
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+#  define _STLP_OUTERMOST_HEADER_ID 0x75
+#  include <stl/_prolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x75) && !defined (_STLP_DONT_POP_HEADER_ID)
+#  define _STLP_DONT_POP_HEADER_ID
+#  define _STLP_UTILITY
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x75) && !defined (_STLP_DONT_POP_HEADER_ID)
+#  ifndef _STLP_INTERNAL_PAIR_H
+#    include <stl/_pair.h>
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x75) || defined (_STLP_DONT_POP_HEADER_ID) || defined (_STLP_IMPORT_VENDOR_STD)
+#  if defined (_STLP_HAS_INCLUDE_NEXT)
+#    include_next <utility>
+#  else
+#    include _STLP_NATIVE_HEADER(utility)
+#  endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x75)
+#  if !defined (_STLP_DONT_POP_HEADER_ID)
+#    include <stl/_epilog.h>
+#    undef _STLP_OUTERMOST_HEADER_ID
+#  else
+#    undef _STLP_DONT_POP_HEADER_ID
+#  endif
+#endif
+
+#endif /* _STLP_UTILITY */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/stlport/stlport/wchar.h b/stlport/stlport/wchar.h
new file mode 100644
index 0000000..6d66799
--- /dev/null
+++ b/stlport/stlport/wchar.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+#  define _STLP_OUTERMOST_HEADER_ID 0x278
+#  include <stl/_cprolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x278) && !defined (_STLP_DONT_POP_HEADER_ID)
+#  define _STLP_DONT_POP_HEADER_ID
+#endif
+
+#if !defined (_STLP_WCE_EVC3) && !defined (_STLP_NO_WCHAR_T)
+
+#  if defined (__BORLANDC__) && !defined (__linux__)
+#    if defined (_STLP_HAS_INCLUDE_NEXT)
+#      include_next <_str.h>
+#    else
+#      include _STLP_NATIVE_CPP_C_HEADER(_str.h)
+#    endif
+#    ifdef __cplusplus
+using _STLP_VENDOR_CSTD::strlen;
+using _STLP_VENDOR_CSTD::strspn;
+#    endif
+#  endif
+
+#  if (((__GNUC__ < 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ < 3))) && defined (__APPLE__)) || defined (__OpenBSD__)
+#    if defined (_STLP_HAS_INCLUDE_NEXT)
+#      include_next <stddef.h>
+#    else
+#      include _STLP_NATIVE_C_HEADER(stddef.h)
+#    endif
+#  else
+#    if defined (_STLP_HAS_INCLUDE_NEXT)
+#      include_next <wchar.h>
+#    else
+#      include _STLP_NATIVE_C_HEADER(wchar.h)
+#    endif
+#  endif
+#endif /* !defined (_STLP_WCE_EVC3) && !defined (_STLP_NO_WCHAR_T) */
+
+#ifndef _STLP_INTERNAL_MBSTATE_T
+#  include <stl/_mbstate_t.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x278)
+#  if ! defined (_STLP_DONT_POP_HEADER_ID)
+#    include <stl/_epilog.h>
+#    undef  _STLP_OUTERMOST_HEADER_ID
+#  else
+#    undef  _STLP_DONT_POP_HEADER_ID
+#  endif
+#endif
+