Delete old versions of GCC.

Change-Id: I710f125d905290e1024cbd67f48299861790c66c

23 files changed, 0 insertions, 14739 deletions

diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/array b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/array
deleted file mode 100644
index c0bd24076..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/array
+++ /dev/null
@@ -1,287 +0,0 @@
-// class template array -*- C++ -*-
-
-// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/array
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-  /**
-   *  @brief A standard container for storing a fixed size sequence of elements.
-   *
-   *  @ingroup sequences
-   *
-   *  Meets the requirements of a <a href="tables.html#65">container</a>, a
-   *  <a href="tables.html#66">reversible container</a>, and a
-   *  <a href="tables.html#67">sequence</a>.
-   *
-   *  Sets support random access iterators.
-   *
-   *  @param  Tp  Type of element. Required to be a complete type.
-   *  @param  N  Number of elements.
-  */
-  template<typename _Tp, std::size_t _Nm>
-    struct array
-    {
-      typedef _Tp 	    			      value_type;
-      typedef value_type&                   	      reference;
-      typedef const value_type&             	      const_reference;
-      typedef value_type*          		      iterator;
-      typedef const value_type*			      const_iterator;
-      typedef std::size_t                    	      size_type;
-      typedef std::ptrdiff_t                   	      difference_type;
-      typedef std::reverse_iterator<iterator>	      reverse_iterator;
-      typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;
-
-      // Support for zero-sized arrays mandatory.
-      value_type _M_instance[_Nm ? _Nm : 1];
-
-      // No explicit construct/copy/destroy for aggregate type.
-
-      void
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      // DR 776.
-      fill(const value_type& __u)
-#else
-      assign(const value_type& __u)
-#endif
-      { std::fill_n(begin(), size(), __u); }
-
-      void
-      swap(array& __other)
-      { std::swap_ranges(begin(), end(), __other.begin()); }
-
-      // Iterators.
-      iterator
-      begin()
-      { return iterator(&_M_instance[0]); }
-
-      const_iterator
-      begin() const 
-      { return const_iterator(&_M_instance[0]); }
-
-      iterator
-      end()
-      { return iterator(&_M_instance[_Nm]); }
-
-      const_iterator
-      end() const
-      { return const_iterator(&_M_instance[_Nm]); }
-
-      reverse_iterator 
-      rbegin()
-      { return reverse_iterator(end()); }
-
-      const_reverse_iterator 
-      rbegin() const
-      { return const_reverse_iterator(end()); }
-
-      reverse_iterator 
-      rend()
-      { return reverse_iterator(begin()); }
-
-      const_reverse_iterator 
-      rend() const
-      { return const_reverse_iterator(begin()); }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      const_iterator
-      cbegin() const 
-      { return const_iterator(&_M_instance[0]); }
-
-      const_iterator
-      cend() const
-      { return const_iterator(&_M_instance[_Nm]); }
-
-      const_reverse_iterator 
-      crbegin() const
-      { return const_reverse_iterator(end()); }
-
-      const_reverse_iterator 
-      crend() const
-      { return const_reverse_iterator(begin()); }
-#endif
-
-      // Capacity.
-      size_type 
-      size() const { return _Nm; }
-
-      size_type 
-      max_size() const { return _Nm; }
-
-      bool 
-      empty() const { return size() == 0; }
-
-      // Element access.
-      reference
-      operator[](size_type __n)
-      { return _M_instance[__n]; }
-
-      const_reference
-      operator[](size_type __n) const
-      { return _M_instance[__n]; }
-
-      reference
-      at(size_type __n)
-      {
-	if (__builtin_expect(__n >= _Nm, false))
-	  std::__throw_out_of_range(__N("array::at"));
-	return _M_instance[__n];
-      }
-
-      const_reference
-      at(size_type __n) const
-      {
-	if (__builtin_expect(__n >= _Nm, false))
-	  std::__throw_out_of_range(__N("array::at"));
-	return _M_instance[__n];
-      }
-
-      reference 
-      front()
-      { return *begin(); }
-
-      const_reference 
-      front() const
-      { return *begin(); }
-
-      reference 
-      back()
-      { return _Nm ? *(end() - 1) : *end(); }
-
-      const_reference 
-      back() const
-      { return _Nm ? *(end() - 1) : *end(); }
-
-      _Tp* 
-      data()
-      { return &_M_instance[0]; }
-
-      const _Tp* 
-      data() const
-      { return &_M_instance[0]; }
-    };
-
-  // Array comparisons.
-  template<typename _Tp, std::size_t _Nm>
-    inline bool 
-    operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-    { return std::equal(__one.begin(), __one.end(), __two.begin()); }
-
-  template<typename _Tp, std::size_t _Nm>
-    inline bool
-    operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-    { return !(__one == __two); }
-
-  template<typename _Tp, std::size_t _Nm>
-    inline bool
-    operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
-    { 
-      return std::lexicographical_compare(__a.begin(), __a.end(),
-					  __b.begin(), __b.end()); 
-    }
-
-  template<typename _Tp, std::size_t _Nm>
-    inline bool
-    operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-    { return __two < __one; }
-
-  template<typename _Tp, std::size_t _Nm>
-    inline bool
-    operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-    { return !(__one > __two); }
-
-  template<typename _Tp, std::size_t _Nm>
-    inline bool
-    operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-    { return !(__one < __two); }
-
-  // Specialized algorithms [6.2.2.2].
-  template<typename _Tp, std::size_t _Nm>
-    inline void
-    swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
-    { std::swap_ranges(__one.begin(), __one.end(), __two.begin()); }
-
-  // Tuple interface to class template array [6.2.2.5].
-
-  /// tuple_size
-  template<typename _Tp> 
-    class tuple_size;
-
-  /// tuple_element
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-  template<std::size_t _Int, typename _Tp>
-#else
-  template<int _Int, typename _Tp>
-#endif
-    class tuple_element;
-
-  template<typename _Tp, std::size_t _Nm>
-    struct tuple_size<array<_Tp, _Nm> >
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-    { static const std::size_t value = _Nm; };
-#else
-    { static const int value = _Nm; };
-#endif
-
-  template<typename _Tp, std::size_t _Nm>
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-    const std::size_t
-#else
-    const int
-#endif
-    tuple_size<array<_Tp, _Nm> >::value;  
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
-#else
-  template<int _Int, typename _Tp, std::size_t _Nm>
-#endif
-    struct tuple_element<_Int, array<_Tp, _Nm> >
-    { typedef _Tp type; };
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
-#else
-  template<int _Int, typename _Tp, std::size_t _Nm>
-#endif
-    inline _Tp&
-    get(array<_Tp, _Nm>& __arr)
-    { return __arr[_Int]; }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
-#else
-  template<int _Int, typename _Tp, std::size_t _Nm>
-#endif
-    inline const _Tp&
-    get(const array<_Tp, _Nm>& __arr)
-    { return __arr[_Int]; }
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/boost_sp_counted_base.h b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/boost_sp_counted_base.h
deleted file mode 100644
index 48e601f21..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/boost_sp_counted_base.h
+++ /dev/null
@@ -1,239 +0,0 @@
-// <tr1_impl/boost_sp_counted_base.h> -*- C++ -*-
-
-// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-//  shared_count.hpp
-//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-
-//  shared_ptr.hpp
-//  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
-//  Copyright (C) 2001, 2002, 2003 Peter Dimov
-
-//  weak_ptr.hpp
-//  Copyright (C) 2001, 2002, 2003 Peter Dimov
-
-//  enable_shared_from_this.hpp
-//  Copyright (C) 2002 Peter Dimov
-
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// GCC Note:  based on version 1.32.0 of the Boost library.
-
-/** @file tr1_impl/boost_sp_counted_base.h
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-  class bad_weak_ptr : public std::exception
-  {
-  public:
-    virtual char const*
-    what() const throw()
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-    { return "std::bad_weak_ptr"; }
-#else
-    { return "tr1::bad_weak_ptr"; }
-#endif
-  };
-
-  // Substitute for bad_weak_ptr object in the case of -fno-exceptions.
-  inline void
-  __throw_bad_weak_ptr()
-  {
-#if __EXCEPTIONS
-    throw bad_weak_ptr();
-#else
-    __builtin_abort();
-#endif
-  }
-
-  using __gnu_cxx::_Lock_policy;
-  using __gnu_cxx::__default_lock_policy;
-  using __gnu_cxx::_S_single;
-  using __gnu_cxx::_S_mutex;
-  using __gnu_cxx::_S_atomic;
-
-  // Empty helper class except when the template argument is _S_mutex.
-  template<_Lock_policy _Lp>
-    class _Mutex_base
-    {
-    protected:
-      // The atomic policy uses fully-fenced builtins, single doesn't care.
-      enum { _S_need_barriers = 0 };
-    };
-
-  template<>
-    class _Mutex_base<_S_mutex>
-    : public __gnu_cxx::__mutex
-    {
-    protected:
-      // This policy is used when atomic builtins are not available.
-      // The replacement atomic operations might not have the necessary
-      // memory barriers.
-      enum { _S_need_barriers = 1 };
-    };
-
-  template<_Lock_policy _Lp = __default_lock_policy>
-    class _Sp_counted_base
-    : public _Mutex_base<_Lp>
-    {
-    public:  
-      _Sp_counted_base()
-      : _M_use_count(1), _M_weak_count(1) { }
-      
-      virtual
-      ~_Sp_counted_base() // nothrow 
-      { }
-  
-      // Called when _M_use_count drops to zero, to release the resources
-      // managed by *this.
-      virtual void
-      _M_dispose() = 0; // nothrow
-      
-      // Called when _M_weak_count drops to zero.
-      virtual void
-      _M_destroy() // nothrow
-      { delete this; }
-      
-      virtual void*
-      _M_get_deleter(const std::type_info&) = 0;
-
-      void
-      _M_add_ref_copy()
-      { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }
-  
-      void
-      _M_add_ref_lock();
-      
-      void
-      _M_release() // nothrow
-      {
-	if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
-	  {
-	    _M_dispose();
-	    // There must be a memory barrier between dispose() and destroy()
-	    // to ensure that the effects of dispose() are observed in the
-	    // thread that runs destroy().
-	    // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
-	    if (_Mutex_base<_Lp>::_S_need_barriers)
-	      {
-	        _GLIBCXX_READ_MEM_BARRIER;
-	        _GLIBCXX_WRITE_MEM_BARRIER;
-	      }
-
-	    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
-						       -1) == 1)
-	      _M_destroy();
-	  }
-      }
-  
-      void
-      _M_weak_add_ref() // nothrow
-      { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }
-
-      void
-      _M_weak_release() // nothrow
-      {
-	if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
-	  {
-	    if (_Mutex_base<_Lp>::_S_need_barriers)
-	      {
-	        // See _M_release(),
-	        // destroy() must observe results of dispose()
-	        _GLIBCXX_READ_MEM_BARRIER;
-	        _GLIBCXX_WRITE_MEM_BARRIER;
-	      }
-	    _M_destroy();
-	  }
-      }
-  
-      long
-      _M_get_use_count() const // nothrow
-      {
-        // No memory barrier is used here so there is no synchronization
-        // with other threads.
-        return const_cast<const volatile _Atomic_word&>(_M_use_count);
-      }
-
-    private:  
-      _Sp_counted_base(_Sp_counted_base const&);
-      _Sp_counted_base& operator=(_Sp_counted_base const&);
-
-      _Atomic_word  _M_use_count;     // #shared
-      _Atomic_word  _M_weak_count;    // #weak + (#shared != 0)
-    };
-
-  template<>
-    inline void
-    _Sp_counted_base<_S_single>::
-    _M_add_ref_lock()
-    {
-      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
-	{
-	  _M_use_count = 0;
-	  __throw_bad_weak_ptr();
-	}
-    }
-
-  template<>
-    inline void
-    _Sp_counted_base<_S_mutex>::
-    _M_add_ref_lock()
-    {
-      __gnu_cxx::__scoped_lock sentry(*this);
-      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
-	{
-	  _M_use_count = 0;
-	  __throw_bad_weak_ptr();
-	}
-    }
-
-  template<> 
-    inline void
-    _Sp_counted_base<_S_atomic>::
-    _M_add_ref_lock()
-    {
-      // Perform lock-free add-if-not-zero operation.
-      _Atomic_word __count;
-      do
-	{
-	  __count = _M_use_count;
-	  if (__count == 0)
-	    __throw_bad_weak_ptr();
-	  
-	  // Replace the current counter value with the old value + 1, as
-	  // long as it's not changed meanwhile. 
-	}
-      while (!__sync_bool_compare_and_swap(&_M_use_count, __count,
-					   __count + 1));
-    }
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cctype b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cctype
deleted file mode 100644
index c76d38c87..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cctype
+++ /dev/null
@@ -1,43 +0,0 @@
-// TR1 cctype -*- C++ -*-
-
-// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/cctype
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-#if _GLIBCXX_USE_C99_CTYPE_TR1
-
-#undef isblank
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-  using ::isblank;
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
-
-#endif
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cfenv b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cfenv
deleted file mode 100644
index 3078c7de6..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cfenv
+++ /dev/null
@@ -1,70 +0,0 @@
-// TR1 cfenv -*- C++ -*-
-
-// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/cfenv
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-#if _GLIBCXX_USE_C99_FENV_TR1
-
-#undef feclearexcept
-#undef fegetexceptflag
-#undef feraiseexcept
-#undef fesetexceptflag
-#undef fetestexcept
-#undef fegetround
-#undef fesetround
-#undef fegetenv
-#undef feholdexcept
-#undef fesetenv
-#undef feupdateenv
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-  // types
-  using ::fenv_t;
-  using ::fexcept_t;
-
-  // functions
-  using ::feclearexcept;
-  using ::fegetexceptflag;
-  using ::feraiseexcept;
-  using ::fesetexceptflag;
-  using ::fetestexcept;
-
-  using ::fegetround;
-  using ::fesetround;
-
-  using ::fegetenv;
-  using ::feholdexcept;
-  using ::fesetenv;
-  using ::feupdateenv;
-  
-_GLIBCXX_END_NAMESPACE_TR1
-}
-
-#endif
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cinttypes b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cinttypes
deleted file mode 100644
index 4a0f9f19d..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cinttypes
+++ /dev/null
@@ -1,64 +0,0 @@
-// TR1 cinttypes -*- C++ -*-
-
-// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/cinttypes
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-#if _GLIBCXX_USE_C99_INTTYPES_TR1
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-  // types
-  using ::imaxdiv_t;
-
-  // functions
-  using ::imaxabs;
-
-  // May collide with _Longlong abs(_Longlong), and is not described
-  // anywhere outside the synopsis.  Likely, a defect.
-  //
-  // intmax_t abs(intmax_t)
-
-  using ::imaxdiv;
-
-  // Likewise, with lldiv_t div(_Longlong, _Longlong).
-  //
-  // imaxdiv_t div(intmax_t, intmax_t)
-
-  using ::strtoimax;
-  using ::strtoumax;
-
-#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1
-  using ::wcstoimax;
-  using ::wcstoumax;
-#endif
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
-
-#endif
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cmath b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cmath
deleted file mode 100644
index 5807380f1..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cmath
+++ /dev/null
@@ -1,902 +0,0 @@
-// TR1 cmath -*- C++ -*-
-
-// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/cmath
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-#if _GLIBCXX_USE_C99_MATH_TR1
-
-#undef acosh
-#undef acoshf
-#undef acoshl
-#undef asinh
-#undef asinhf
-#undef asinhl
-#undef atanh
-#undef atanhf
-#undef atanhl
-#undef cbrt
-#undef cbrtf
-#undef cbrtl
-#undef copysign
-#undef copysignf
-#undef copysignl
-#undef erf
-#undef erff
-#undef erfl
-#undef erfc
-#undef erfcf
-#undef erfcl
-#undef exp2
-#undef exp2f
-#undef exp2l
-#undef expm1
-#undef expm1f
-#undef expm1l
-#undef fdim
-#undef fdimf
-#undef fdiml
-#undef fma
-#undef fmaf
-#undef fmal
-#undef fmax
-#undef fmaxf
-#undef fmaxl
-#undef fmin
-#undef fminf
-#undef fminl
-#undef hypot
-#undef hypotf
-#undef hypotl
-#undef ilogb
-#undef ilogbf
-#undef ilogbl
-#undef lgamma
-#undef lgammaf
-#undef lgammal
-#undef llrint
-#undef llrintf
-#undef llrintl
-#undef llround
-#undef llroundf
-#undef llroundl
-#undef log1p
-#undef log1pf
-#undef log1pl
-#undef log2
-#undef log2f
-#undef log2l
-#undef logb
-#undef logbf
-#undef logbl
-#undef lrint
-#undef lrintf
-#undef lrintl
-#undef lround
-#undef lroundf
-#undef lroundl
-#undef nan
-#undef nanf
-#undef nanl
-#undef nearbyint
-#undef nearbyintf
-#undef nearbyintl
-#undef nextafter
-#undef nextafterf
-#undef nextafterl
-#undef nexttoward
-#undef nexttowardf
-#undef nexttowardl
-#undef remainder
-#undef remainderf
-#undef remainderl
-#undef remquo
-#undef remquof
-#undef remquol
-#undef rint
-#undef rintf
-#undef rintl
-#undef round
-#undef roundf
-#undef roundl
-#undef scalbln
-#undef scalblnf
-#undef scalblnl
-#undef scalbn
-#undef scalbnf
-#undef scalbnl
-#undef tgamma
-#undef tgammaf
-#undef tgammal
-#undef trunc
-#undef truncf
-#undef truncl
-
-#endif
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-#if _GLIBCXX_USE_C99_MATH_TR1
-
-  // types
-  using ::double_t;
-  using ::float_t;
-
-  // functions
-  using ::acosh;
-  using ::acoshf;
-  using ::acoshl;
-
-  using ::asinh;
-  using ::asinhf;
-  using ::asinhl;
-
-  using ::atanh;
-  using ::atanhf;
-  using ::atanhl;
-
-  using ::cbrt;
-  using ::cbrtf;
-  using ::cbrtl;
-
-  using ::copysign;
-  using ::copysignf;
-  using ::copysignl;
-
-  using ::erf;
-  using ::erff;
-  using ::erfl;
-
-  using ::erfc;
-  using ::erfcf;
-  using ::erfcl;
-
-  using ::exp2;
-  using ::exp2f;
-  using ::exp2l;
-
-  using ::expm1;
-  using ::expm1f;
-  using ::expm1l;
-
-  using ::fdim;
-  using ::fdimf;
-  using ::fdiml;
-
-  using ::fma;
-  using ::fmaf;
-  using ::fmal;
-
-  using ::fmax;
-  using ::fmaxf;
-  using ::fmaxl;
-
-  using ::fmin;
-  using ::fminf;
-  using ::fminl;
-
-  using ::hypot;
-  using ::hypotf;
-  using ::hypotl;
-
-  using ::ilogb;
-  using ::ilogbf;
-  using ::ilogbl;
-
-  using ::lgamma;
-  using ::lgammaf;
-  using ::lgammal;
-
-  using ::llrint;
-  using ::llrintf;
-  using ::llrintl;
-
-  using ::llround;
-  using ::llroundf;
-  using ::llroundl;
-
-  using ::log1p;
-  using ::log1pf;
-  using ::log1pl;
-
-  using ::log2;
-  using ::log2f;
-  using ::log2l;
-
-  using ::logb;
-  using ::logbf;
-  using ::logbl;
-
-  using ::lrint;
-  using ::lrintf;
-  using ::lrintl;
-
-  using ::lround;
-  using ::lroundf;
-  using ::lroundl;
-
-  using ::nan;
-  using ::nanf;
-  using ::nanl;
-
-  using ::nearbyint;
-  using ::nearbyintf;
-  using ::nearbyintl;
-
-  using ::nextafter;
-  using ::nextafterf;
-  using ::nextafterl;
-
-  using ::nexttoward;
-  using ::nexttowardf;
-  using ::nexttowardl;
-
-  using ::remainder;
-  using ::remainderf;
-  using ::remainderl;
-
-  using ::remquo;
-  using ::remquof;
-  using ::remquol;
-
-  using ::rint;
-  using ::rintf;
-  using ::rintl;
-
-  using ::round;
-  using ::roundf;
-  using ::roundl;
-
-  using ::scalbln;
-  using ::scalblnf;
-  using ::scalblnl;
-
-  using ::scalbn;
-  using ::scalbnf;
-  using ::scalbnl;
-
-  using ::tgamma;
-  using ::tgammaf;
-  using ::tgammal;
-
-  using ::trunc;
-  using ::truncf;
-  using ::truncl;
-
-#endif
-
-#if _GLIBCXX_USE_C99_MATH
-#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
-
-  /// Function template definitions [8.16.3].
-  using std::signbit;
-  
-  using std::fpclassify;
-
-  using std::isfinite;
-  using std::isinf;
-  using std::isnan;
-  using std::isnormal;
-
-  using std::isgreater;
-  using std::isgreaterequal;
-  using std::isless;
-  using std::islessequal;
-  using std::islessgreater;
-  using std::isunordered;
-#endif
-#endif
-
-#if _GLIBCXX_USE_C99_MATH_TR1
-
-  /// Additional overloads [8.16.4].
-  using std::acos;
-
-  inline float
-  acosh(float __x)
-  { return __builtin_acoshf(__x); }
-
-  inline long double
-  acosh(long double __x)
-  { return __builtin_acoshl(__x); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type 
-    acosh(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return acosh(__type(__x));
-    }
-
-  using std::asin;
-
-  inline float
-  asinh(float __x)
-  { return __builtin_asinhf(__x); }
-
-  inline long double
-  asinh(long double __x)
-  { return __builtin_asinhl(__x); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type 
-    asinh(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return asinh(__type(__x));
-    }
-
-  using std::atan;
-  using std::atan2;
-
-  inline float
-  atanh(float __x)
-  { return __builtin_atanhf(__x); }
-
-  inline long double
-  atanh(long double __x)
-  { return __builtin_atanhl(__x); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type 
-    atanh(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return atanh(__type(__x));
-    }
-
-  inline float
-  cbrt(float __x)
-  { return __builtin_cbrtf(__x); }
-
-  inline long double
-  cbrt(long double __x)
-  { return __builtin_cbrtl(__x); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type 
-    cbrt(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return cbrt(__type(__x));
-    }
-
-  using std::ceil;
-
-  inline float
-  copysign(float __x, float __y)
-  { return __builtin_copysignf(__x, __y); }
-
-  inline long double
-  copysign(long double __x, long double __y)
-  { return __builtin_copysignl(__x, __y); }
-
-  template<typename _Tp, typename _Up>
-    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    copysign(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return copysign(__type(__x), __type(__y));
-    }
-
-  using std::cos;
-  using std::cosh;  
-
-  inline float
-  erf(float __x)
-  { return __builtin_erff(__x); }
-
-  inline long double
-  erf(long double __x)
-  { return __builtin_erfl(__x); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type 
-    erf(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return erf(__type(__x));
-    }
-
-  inline float
-  erfc(float __x)
-  { return __builtin_erfcf(__x); }
-
-  inline long double
-  erfc(long double __x)
-  { return __builtin_erfcl(__x); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type 
-    erfc(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return erfc(__type(__x));
-    }
-
-  using std::exp;
-
-  inline float
-  exp2(float __x)
-  { return __builtin_exp2f(__x); }
-
-  inline long double
-  exp2(long double __x)
-  { return __builtin_exp2l(__x); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type 
-    exp2(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return exp2(__type(__x));
-    }
-
-  inline float
-  expm1(float __x)
-  { return __builtin_expm1f(__x); }
-
-  inline long double
-  expm1(long double __x)
-  { return __builtin_expm1l(__x); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type 
-    expm1(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return expm1(__type(__x));
-    }
-
-  using std::fabs;
-
-  inline float
-  fdim(float __x, float __y)
-  { return __builtin_fdimf(__x, __y); }
-
-  inline long double
-  fdim(long double __x, long double __y)
-  { return __builtin_fdiml(__x, __y); }
-
-  template<typename _Tp, typename _Up>
-    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    fdim(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return fdim(__type(__x), __type(__y));
-    }
-
-  using std::floor;
-
-  inline float
-  fma(float __x, float __y, float __z)
-  { return __builtin_fmaf(__x, __y, __z); }
-
-  inline long double
-  fma(long double __x, long double __y, long double __z)
-  { return __builtin_fmal(__x, __y, __z); }
-
-  template<typename _Tp, typename _Up, typename _Vp>
-    inline typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
-    fma(_Tp __x, _Up __y, _Vp __z)
-    {
-      typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
-      return fma(__type(__x), __type(__y), __type(__z));
-    }
-
-  inline float
-  fmax(float __x, float __y)
-  { return __builtin_fmaxf(__x, __y); }
-
-  inline long double
-  fmax(long double __x, long double __y)
-  { return __builtin_fmaxl(__x, __y); }
-
-  template<typename _Tp, typename _Up>
-    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    fmax(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return fmax(__type(__x), __type(__y));
-    }
-
-  inline float
-  fmin(float __x, float __y)
-  { return __builtin_fminf(__x, __y); }
-
-  inline long double
-  fmin(long double __x, long double __y)
-  { return __builtin_fminl(__x, __y); }
-
-  template<typename _Tp, typename _Up>
-    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    fmin(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return fmin(__type(__x), __type(__y));
-    }
-
-  using std::fmod;
-  using std::frexp;
-
-  inline float
-  hypot(float __x, float __y)
-  { return __builtin_hypotf(__x, __y); }
-
-  inline long double
-  hypot(long double __x, long double __y)
-  { return __builtin_hypotl(__x, __y); }
-
-  template<typename _Tp, typename _Up>
-    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    hypot(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return hypot(__type(__x), __type(__y));
-    }
-
-  inline int
-  ilogb(float __x)
-  { return __builtin_ilogbf(__x); }
-
-  inline int
-  ilogb(long double __x)
-  { return __builtin_ilogbl(__x); }
-
-  template<typename _Tp>
-    inline int
-    ilogb(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return ilogb(__type(__x));
-    }
-
-  using std::ldexp;
-
-  inline float
-  lgamma(float __x)
-  { return __builtin_lgammaf(__x); }
-
-  inline long double
-  lgamma(long double __x)
-  { return __builtin_lgammal(__x); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type 
-    lgamma(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return lgamma(__type(__x));
-    }
-
-  inline long long
-  llrint(float __x)
-  { return __builtin_llrintf(__x); }
-
-  inline long long
-  llrint(long double __x)
-  { return __builtin_llrintl(__x); }
-
-  template<typename _Tp>
-    inline long long
-    llrint(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return llrint(__type(__x));
-    }
-
-  inline long long
-  llround(float __x)
-  { return __builtin_llroundf(__x); }
-
-  inline long long
-  llround(long double __x)
-  { return __builtin_llroundl(__x); }
-
-  template<typename _Tp>
-    inline long long
-    llround(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return llround(__type(__x));
-    }
-
-  using std::log;
-  using std::log10;
-
-  inline float
-  log1p(float __x)
-  { return __builtin_log1pf(__x); }
-
-  inline long double
-  log1p(long double __x)
-  { return __builtin_log1pl(__x); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type 
-    log1p(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return log1p(__type(__x));
-    }
-
-  // DR 568.
-  inline float
-  log2(float __x)
-  { return __builtin_log2f(__x); }
-
-  inline long double
-  log2(long double __x)
-  { return __builtin_log2l(__x); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type 
-    log2(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return log2(__type(__x));
-    }
-
-  inline float
-  logb(float __x)
-  { return __builtin_logbf(__x); }
-
-  inline long double
-  logb(long double __x)
-  { return __builtin_logbl(__x); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type 
-    logb(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return logb(__type(__x));
-    }
-
-  inline long
-  lrint(float __x)
-  { return __builtin_lrintf(__x); }
-
-  inline long
-  lrint(long double __x)
-  { return __builtin_lrintl(__x); }
-
-  template<typename _Tp>
-    inline long
-    lrint(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return lrint(__type(__x));
-    }
-
-  inline long
-  lround(float __x)
-  { return __builtin_lroundf(__x); }
-
-  inline long
-  lround(long double __x)
-  { return __builtin_lroundl(__x); }
-
-  template<typename _Tp>
-    inline long
-    lround(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return lround(__type(__x));
-    }
-
-  inline float
-  nearbyint(float __x)
-  { return __builtin_nearbyintf(__x); }
-
-  inline long double
-  nearbyint(long double __x)
-  { return __builtin_nearbyintl(__x); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type 
-    nearbyint(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return nearbyint(__type(__x));
-    }
-
-  inline float
-  nextafter(float __x, float __y)
-  { return __builtin_nextafterf(__x, __y); }
-
-  inline long double
-  nextafter(long double __x, long double __y)
-  { return __builtin_nextafterl(__x, __y); }
-
-  template<typename _Tp, typename _Up>
-    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    nextafter(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return nextafter(__type(__x), __type(__y));
-    }
-
-  inline float
-  nexttoward(float __x, long double __y)
-  { return __builtin_nexttowardf(__x, __y); }
-
-  inline long double
-  nexttoward(long double __x, long double __y)
-  { return __builtin_nexttowardl(__x, __y); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type
-    nexttoward(_Tp __x, long double __y)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return nexttoward(__type(__x), __y);
-    }
-
-  // DR 550. What should the return type of pow(float,int) be?
-  // NB: C++0x and TR1 != C++03.
-  //   using std::pow;
-
-  inline float
-  remainder(float __x, float __y)
-  { return __builtin_remainderf(__x, __y); }
-
-  inline long double
-  remainder(long double __x, long double __y)
-  { return __builtin_remainderl(__x, __y); }
-
-  template<typename _Tp, typename _Up>
-    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    remainder(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return remainder(__type(__x), __type(__y));
-    }
-
-  inline float
-  remquo(float __x, float __y, int* __pquo)
-  { return __builtin_remquof(__x, __y, __pquo); }
-
-  inline long double
-  remquo(long double __x, long double __y, int* __pquo)
-  { return __builtin_remquol(__x, __y, __pquo); }
-
-  template<typename _Tp, typename _Up>
-    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    remquo(_Tp __x, _Up __y, int* __pquo)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return remquo(__type(__x), __type(__y), __pquo);
-    }
-
-  inline float
-  rint(float __x)
-  { return __builtin_rintf(__x); }
-
-  inline long double
-  rint(long double __x)
-  { return __builtin_rintl(__x); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type
-    rint(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return rint(__type(__x));
-    }
-
-  inline float
-  round(float __x)
-  { return __builtin_roundf(__x); }
-
-  inline long double
-  round(long double __x)
-  { return __builtin_roundl(__x); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type
-    round(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return round(__type(__x));
-    }
-
-  inline float
-  scalbln(float __x, long __ex)
-  { return __builtin_scalblnf(__x, __ex); }
-
-  inline long double
-  scalbln(long double __x, long __ex)
-  { return __builtin_scalblnl(__x, __ex); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type 
-    scalbln(_Tp __x, long __ex)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return scalbln(__type(__x), __ex);
-    }
- 
-  inline float
-  scalbn(float __x, int __ex)
-  { return __builtin_scalbnf(__x, __ex); }
-
-  inline long double
-  scalbn(long double __x, int __ex)
-  { return __builtin_scalbnl(__x, __ex); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type 
-    scalbn(_Tp __x, int __ex)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return scalbn(__type(__x), __ex);
-    }
-
-  using std::sin;
-  using std::sinh;
-  using std::sqrt;
-  using std::tan;
-  using std::tanh;
-
-  inline float
-  tgamma(float __x)
-  { return __builtin_tgammaf(__x); }
-
-  inline long double
-  tgamma(long double __x)
-  { return __builtin_tgammal(__x); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type 
-    tgamma(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return tgamma(__type(__x));
-    }
- 
-  inline float
-  trunc(float __x)
-  { return __builtin_truncf(__x); }
-
-  inline long double
-  trunc(long double __x)
-  { return __builtin_truncl(__x); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type 
-    trunc(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return trunc(__type(__x));
-    }
-
-#endif
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/complex b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/complex
deleted file mode 100644
index 615fe1886..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/complex
+++ /dev/null
@@ -1,370 +0,0 @@
-// TR1 complex -*- C++ -*-
-
-// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/complex
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-  /**
-   * @addtogroup complex_numbers
-   * @{
-   */
-
-  // Forward declarations.
-  template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
-  template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
-  template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
-
-  template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
-  template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
-  template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-  // DR 595.
-  template<typename _Tp> _Tp               fabs(const std::complex<_Tp>&);
-#else
-  template<typename _Tp> std::complex<_Tp> fabs(const std::complex<_Tp>&);
-#endif
-
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    __complex_acos(const std::complex<_Tp>& __z)
-    {
-      const std::complex<_Tp> __t = std::_GLIBCXX_TR1 asin(__z);
-      const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
-      return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
-    }
-
-#if _GLIBCXX_USE_C99_COMPLEX_TR1
-  inline __complex__ float
-  __complex_acos(__complex__ float __z)
-  { return __builtin_cacosf(__z); }
-
-  inline __complex__ double
-  __complex_acos(__complex__ double __z)
-  { return __builtin_cacos(__z); }
-
-  inline __complex__ long double
-  __complex_acos(const __complex__ long double& __z)
-  { return __builtin_cacosl(__z); }
-
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    acos(const std::complex<_Tp>& __z)
-    { return __complex_acos(__z.__rep()); }
-#else
-  /// acos(__z) [8.1.2].
-  //  Effects:  Behaves the same as C99 function cacos, defined
-  //            in subclause 7.3.5.1.
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    acos(const std::complex<_Tp>& __z)
-    { return __complex_acos(__z); }
-#endif
-
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    __complex_asin(const std::complex<_Tp>& __z)
-    {
-      std::complex<_Tp> __t(-__z.imag(), __z.real());
-      __t = std::_GLIBCXX_TR1 asinh(__t);
-      return std::complex<_Tp>(__t.imag(), -__t.real());
-    }
-
-#if _GLIBCXX_USE_C99_COMPLEX_TR1
-  inline __complex__ float
-  __complex_asin(__complex__ float __z)
-  { return __builtin_casinf(__z); }
-
-  inline __complex__ double
-  __complex_asin(__complex__ double __z)
-  { return __builtin_casin(__z); }
-
-  inline __complex__ long double
-  __complex_asin(const __complex__ long double& __z)
-  { return __builtin_casinl(__z); }
-
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    asin(const std::complex<_Tp>& __z)
-    { return __complex_asin(__z.__rep()); }
-#else
-  /// asin(__z) [8.1.3].
-  //  Effects:  Behaves the same as C99 function casin, defined
-  //            in subclause 7.3.5.2.
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    asin(const std::complex<_Tp>& __z)
-    { return __complex_asin(__z); }
-#endif
-  
-  template<typename _Tp>
-    std::complex<_Tp>
-    __complex_atan(const std::complex<_Tp>& __z)
-    {
-      const _Tp __r2 = __z.real() * __z.real();
-      const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
-
-      _Tp __num = __z.imag() + _Tp(1.0);
-      _Tp __den = __z.imag() - _Tp(1.0);
-
-      __num = __r2 + __num * __num;
-      __den = __r2 + __den * __den;
-
-      return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
-			       _Tp(0.25) * log(__num / __den));
-    }
-
-#if _GLIBCXX_USE_C99_COMPLEX_TR1
-  inline __complex__ float
-  __complex_atan(__complex__ float __z)
-  { return __builtin_catanf(__z); }
-
-  inline __complex__ double
-  __complex_atan(__complex__ double __z)
-  { return __builtin_catan(__z); }
-
-  inline __complex__ long double
-  __complex_atan(const __complex__ long double& __z)
-  { return __builtin_catanl(__z); }
-
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    atan(const std::complex<_Tp>& __z)
-    { return __complex_atan(__z.__rep()); }
-#else
-  /// atan(__z) [8.1.4].
-  //  Effects:  Behaves the same as C99 function catan, defined
-  //            in subclause 7.3.5.3.
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    atan(const std::complex<_Tp>& __z)
-    { return __complex_atan(__z); }
-#endif
-
-  template<typename _Tp>
-    std::complex<_Tp>
-    __complex_acosh(const std::complex<_Tp>& __z)
-    {
-      std::complex<_Tp> __t((__z.real() - __z.imag())
-			    * (__z.real() + __z.imag()) - _Tp(1.0),
-			    _Tp(2.0) * __z.real() * __z.imag());
-      __t = std::sqrt(__t);
-
-      return std::log(__t + __z);
-    }
-
-#if _GLIBCXX_USE_C99_COMPLEX_TR1
-  inline __complex__ float
-  __complex_acosh(__complex__ float __z)
-  { return __builtin_cacoshf(__z); }
-
-  inline __complex__ double
-  __complex_acosh(__complex__ double __z)
-  { return __builtin_cacosh(__z); }
-
-  inline __complex__ long double
-  __complex_acosh(const __complex__ long double& __z)
-  { return __builtin_cacoshl(__z); }
-
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    acosh(const std::complex<_Tp>& __z)
-    { return __complex_acosh(__z.__rep()); }
-#else
-  /// acosh(__z) [8.1.5].
-  //  Effects:  Behaves the same as C99 function cacosh, defined
-  //            in subclause 7.3.6.1.
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    acosh(const std::complex<_Tp>& __z)
-    { return __complex_acosh(__z); }
-#endif
-
-  template<typename _Tp>
-    std::complex<_Tp>
-    __complex_asinh(const std::complex<_Tp>& __z)
-    {
-      std::complex<_Tp> __t((__z.real() - __z.imag())
-			    * (__z.real() + __z.imag()) + _Tp(1.0),
-			    _Tp(2.0) * __z.real() * __z.imag());
-      __t = std::sqrt(__t);
-
-      return std::log(__t + __z);
-    }
-
-#if _GLIBCXX_USE_C99_COMPLEX_TR1
-  inline __complex__ float
-  __complex_asinh(__complex__ float __z)
-  { return __builtin_casinhf(__z); }
-
-  inline __complex__ double
-  __complex_asinh(__complex__ double __z)
-  { return __builtin_casinh(__z); }
-
-  inline __complex__ long double
-  __complex_asinh(const __complex__ long double& __z)
-  { return __builtin_casinhl(__z); }
-
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    asinh(const std::complex<_Tp>& __z)
-    { return __complex_asinh(__z.__rep()); }
-#else
-  /// asinh(__z) [8.1.6].
-  //  Effects:  Behaves the same as C99 function casin, defined
-  //            in subclause 7.3.6.2.
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    asinh(const std::complex<_Tp>& __z)
-    { return __complex_asinh(__z); }
-#endif
-
-  template<typename _Tp>
-    std::complex<_Tp>
-    __complex_atanh(const std::complex<_Tp>& __z)
-    {
-      const _Tp __i2 = __z.imag() * __z.imag();
-      const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
-
-      _Tp __num = _Tp(1.0) + __z.real();
-      _Tp __den = _Tp(1.0) - __z.real();
-
-      __num = __i2 + __num * __num;
-      __den = __i2 + __den * __den;
-
-      return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
-			       _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
-    }
-
-#if _GLIBCXX_USE_C99_COMPLEX_TR1
-  inline __complex__ float
-  __complex_atanh(__complex__ float __z)
-  { return __builtin_catanhf(__z); }
-
-  inline __complex__ double
-  __complex_atanh(__complex__ double __z)
-  { return __builtin_catanh(__z); }
-
-  inline __complex__ long double
-  __complex_atanh(const __complex__ long double& __z)
-  { return __builtin_catanhl(__z); }
-
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    atanh(const std::complex<_Tp>& __z)
-    { return __complex_atanh(__z.__rep()); }
-#else
-  /// atanh(__z) [8.1.7].
-  //  Effects:  Behaves the same as C99 function catanh, defined
-  //            in subclause 7.3.6.3.
-  template<typename _Tp>
-    inline std::complex<_Tp>
-    atanh(const std::complex<_Tp>& __z)
-    { return __complex_atanh(__z); }
-#endif
-
-  template<typename _Tp>
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-    inline _Tp
-#else
-    inline std::complex<_Tp>
-#endif
-    /// fabs(__z) [8.1.8].
-    //  Effects:  Behaves the same as C99 function cabs, defined
-    //            in subclause 7.3.8.1.
-    fabs(const std::complex<_Tp>& __z)
-    { return std::abs(__z); }
-
-  /// Additional overloads [8.1.9].
-#if (defined(_GLIBCXX_INCLUDE_AS_CXX0X) \
-     || (defined(_GLIBCXX_INCLUDE_AS_TR1) \
-	 && !defined(__GXX_EXPERIMENTAL_CXX0X__)))
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type
-    arg(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return std::arg(std::complex<__type>(__x));
-    }
-
-  template<typename _Tp>
-    inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
-    conj(_Tp __x)
-    { return __x; }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type
-    imag(_Tp)
-    { return _Tp(); }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type
-    norm(_Tp __x)
-    {
-      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-      return __type(__x) * __type(__x);
-    }
-
-  template<typename _Tp>
-    inline typename __gnu_cxx::__promote<_Tp>::__type
-    real(_Tp __x)
-    { return __x; }
-
-#endif
-
-  template<typename _Tp, typename _Up>
-    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
-    pow(const std::complex<_Tp>& __x, const _Up& __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return std::pow(std::complex<__type>(__x), __type(__y));
-    }
-
-  template<typename _Tp, typename _Up>
-    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
-    pow(const _Tp& __x, const std::complex<_Up>& __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return std::pow(__type(__x), std::complex<__type>(__y));
-    }
-
-  template<typename _Tp, typename _Up>
-    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
-    pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return std::pow(std::complex<__type>(__x),
-		      std::complex<__type>(__y));
-    }
-
-  // @} group complex_numbers
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cstdint b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cstdint
deleted file mode 100644
index d1403887a..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cstdint
+++ /dev/null
@@ -1,75 +0,0 @@
-// TR1 cstdint -*- C++ -*-
-
-// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/cstdint
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-#if _GLIBCXX_USE_C99_STDINT_TR1
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-  using ::int8_t;
-  using ::int16_t;
-  using ::int32_t;
-  using ::int64_t;
-
-  using ::int_fast8_t;
-  using ::int_fast16_t;
-  using ::int_fast32_t;
-  using ::int_fast64_t;
-
-  using ::int_least8_t;
-  using ::int_least16_t;
-  using ::int_least32_t;
-  using ::int_least64_t;
-
-  using ::intmax_t;
-  using ::intptr_t;
-  
-  using ::uint8_t;
-  using ::uint16_t;
-  using ::uint32_t;
-  using ::uint64_t;
-
-  using ::uint_fast8_t;
-  using ::uint_fast16_t;
-  using ::uint_fast32_t;
-  using ::uint_fast64_t;
-
-  using ::uint_least8_t;
-  using ::uint_least16_t;
-  using ::uint_least32_t;
-  using ::uint_least64_t;
-
-  using ::uintmax_t;
-  using ::uintptr_t;
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
-
-#endif
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cstdio b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cstdio
deleted file mode 100644
index 8b100cceb..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cstdio
+++ /dev/null
@@ -1,44 +0,0 @@
-// TR1 cstdio -*- C++ -*-
-
-// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/cstdio
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-#if _GLIBCXX_USE_C99
-  using std::snprintf;
-  using std::vsnprintf;
-
-  using std::vfscanf;
-  using std::vscanf;
-  using std::vsscanf;
-#endif
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cstdlib b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cstdlib
deleted file mode 100644
index e9a590f0b..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cstdlib
+++ /dev/null
@@ -1,65 +0,0 @@
-// TR1 cstdlib -*- C++ -*-
-
-// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/cstdlib
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-#if _GLIBCXX_HOSTED
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-#if _GLIBCXX_USE_C99
-
-#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
-  // types
-  using std::lldiv_t;
-
-  // functions
-  using std::llabs;
-  using std::lldiv;
-#endif
-
-  using std::atoll;
-  using std::strtoll;
-  using std::strtoull;
-
-  using std::strtof;
-  using std::strtold;
-
-  // overloads
-  using std::abs;
-#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
-  using std::div;
-#endif
-
-#endif
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
-
-#endif
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cwchar b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cwchar
deleted file mode 100644
index 2a9004d40..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cwchar
+++ /dev/null
@@ -1,58 +0,0 @@
-// TR1 cwchar -*- C++ -*-
-
-// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/cwchar
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-#if _GLIBCXX_USE_WCHAR_T
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-#if _GLIBCXX_HAVE_WCSTOF
-  using std::wcstof;
-#endif
-#if _GLIBCXX_HAVE_VFWSCANF
-  using std::vfwscanf;
-#endif
-#if _GLIBCXX_HAVE_VSWSCANF
-  using std::vswscanf;
-#endif
-#if _GLIBCXX_HAVE_VWSCANF
-  using std::vwscanf;
-#endif
-
-#if _GLIBCXX_USE_C99
-  using std::wcstold;
-  using std::wcstoll;
-  using std::wcstoull;
-#endif
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
-
-#endif
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cwctype b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cwctype
deleted file mode 100644
index 3135d3641..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/cwctype
+++ /dev/null
@@ -1,43 +0,0 @@
-// TR1 cwctype -*- C++ -*-
-
-// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/cwctype
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-#if _GLIBCXX_USE_WCHAR_T
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-#if _GLIBCXX_HAVE_ISWBLANK
-  using std::iswblank;
-#endif  
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
-
-#endif
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/functional b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/functional
deleted file mode 100644
index 7e6eaeb26..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/functional
+++ /dev/null
@@ -1,2130 +0,0 @@
-// TR1 functional header -*- C++ -*-
-
-// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/functional
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-  template<typename _MemberPointer>
-    class _Mem_fn;
-
-  /**
-   *  Actual implementation of _Has_result_type, which uses SFINAE to
-   *  determine if the type _Tp has a publicly-accessible member type
-   *  result_type.
-  */
-  template<typename _Tp>
-    class _Has_result_type_helper : __sfinae_types
-    {
-      template<typename _Up>
-        struct _Wrap_type
-	{ };
-
-      template<typename _Up>
-        static __one __test(_Wrap_type<typename _Up::result_type>*);
-
-      template<typename _Up>
-        static __two __test(...);
-
-    public:
-      static const bool value = sizeof(__test<_Tp>(0)) == 1;
-    };
-
-  template<typename _Tp>
-    struct _Has_result_type
-    : integral_constant<bool,
-	      _Has_result_type_helper<typename remove_cv<_Tp>::type>::value>
-    { };
-
-  /**
-   *  
-  */
-  /// If we have found a result_type, extract it.
-  template<bool _Has_result_type, typename _Functor>
-    struct _Maybe_get_result_type
-    { };
-
-  template<typename _Functor>
-    struct _Maybe_get_result_type<true, _Functor>
-    {
-      typedef typename _Functor::result_type result_type;
-    };
-
-  /**
-   *  Base class for any function object that has a weak result type, as
-   *  defined in 3.3/3 of TR1.
-  */
-  template<typename _Functor>
-    struct _Weak_result_type_impl
-    : _Maybe_get_result_type<_Has_result_type<_Functor>::value, _Functor>
-    {
-    };
-
-  /// Retrieve the result type for a function type.
-  template<typename _Res, typename... _ArgTypes> 
-    struct _Weak_result_type_impl<_Res(_ArgTypes...)>
-    {
-      typedef _Res result_type;
-    };
-
-  /// Retrieve the result type for a function reference.
-  template<typename _Res, typename... _ArgTypes> 
-    struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
-    {
-      typedef _Res result_type;
-    };
-
-  /// Retrieve the result type for a function pointer.
-  template<typename _Res, typename... _ArgTypes> 
-    struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
-    {
-      typedef _Res result_type;
-    };
-
-  /// Retrieve result type for a member function pointer. 
-  template<typename _Res, typename _Class, typename... _ArgTypes> 
-    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
-    {
-      typedef _Res result_type;
-    };
-
-  /// Retrieve result type for a const member function pointer. 
-  template<typename _Res, typename _Class, typename... _ArgTypes> 
-    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
-    {
-      typedef _Res result_type;
-    };
-
-  /// Retrieve result type for a volatile member function pointer. 
-  template<typename _Res, typename _Class, typename... _ArgTypes> 
-    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
-    {
-      typedef _Res result_type;
-    };
-
-  /// Retrieve result type for a const volatile member function pointer. 
-  template<typename _Res, typename _Class, typename... _ArgTypes> 
-    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)const volatile>
-    {
-      typedef _Res result_type;
-    };
-
-  /**
-   *  Strip top-level cv-qualifiers from the function object and let
-   *  _Weak_result_type_impl perform the real work.
-  */
-  template<typename _Functor>
-    struct _Weak_result_type
-    : _Weak_result_type_impl<typename remove_cv<_Functor>::type>
-    {
-    };
-
-  template<typename _Signature>
-    class result_of;
-
-  /**
-   *  Actual implementation of result_of. When _Has_result_type is
-   *  true, gets its result from _Weak_result_type. Otherwise, uses
-   *  the function object's member template result to extract the
-   *  result type.
-  */
-  template<bool _Has_result_type, typename _Signature>
-    struct _Result_of_impl;
-
-  // Handle member data pointers using _Mem_fn's logic
-  template<typename _Res, typename _Class, typename _T1>
-    struct _Result_of_impl<false, _Res _Class::*(_T1)>
-    {
-      typedef typename _Mem_fn<_Res _Class::*>
-                ::template _Result_type<_T1>::type type;
-    };
-
-  /**
-   * Determine whether we can determine a result type from @c Functor 
-   * alone.
-   */ 
-  template<typename _Functor, typename... _ArgTypes>
-    class result_of<_Functor(_ArgTypes...)>
-    : public _Result_of_impl<
-               _Has_result_type<_Weak_result_type<_Functor> >::value,
-               _Functor(_ArgTypes...)>
-    {
-    };
-
-  /// We already know the result type for @c Functor; use it.
-  template<typename _Functor, typename... _ArgTypes>
-    struct _Result_of_impl<true, _Functor(_ArgTypes...)>
-    {
-      typedef typename _Weak_result_type<_Functor>::result_type type;
-    };
-
-  /**
-   * We need to compute the result type for this invocation the hard 
-   * way.
-   */
-  template<typename _Functor, typename... _ArgTypes>
-    struct _Result_of_impl<false, _Functor(_ArgTypes...)>
-    {
-      typedef typename _Functor
-                ::template result<_Functor(_ArgTypes...)>::type type;
-    };
-
-  /**
-   * It is unsafe to access ::result when there are zero arguments, so we 
-   * return @c void instead.
-   */
-  template<typename _Functor>
-    struct _Result_of_impl<false, _Functor()>
-    {
-      typedef void type;
-    };
-
-  /// Determines if the type _Tp derives from unary_function.
-  template<typename _Tp>
-    struct _Derives_from_unary_function : __sfinae_types
-    {
-    private:
-      template<typename _T1, typename _Res>
-        static __one __test(const volatile unary_function<_T1, _Res>*);
-
-      // It's tempting to change "..." to const volatile void*, but
-      // that fails when _Tp is a function type.
-      static __two __test(...);
-
-    public:
-      static const bool value = sizeof(__test((_Tp*)0)) == 1;
-    };
-
-  /// Determines if the type _Tp derives from binary_function.
-  template<typename _Tp>
-    struct _Derives_from_binary_function : __sfinae_types
-    {
-    private:
-      template<typename _T1, typename _T2, typename _Res>
-        static __one __test(const volatile binary_function<_T1, _T2, _Res>*);
-
-      // It's tempting to change "..." to const volatile void*, but
-      // that fails when _Tp is a function type.
-      static __two __test(...);
-
-    public:
-      static const bool value = sizeof(__test((_Tp*)0)) == 1;
-    };
-
-  /// Turns a function type into a function pointer type
-  template<typename _Tp, bool _IsFunctionType = is_function<_Tp>::value>
-    struct _Function_to_function_pointer
-    {
-      typedef _Tp type;
-    };
-
-  template<typename _Tp>
-    struct _Function_to_function_pointer<_Tp, true>
-    {
-      typedef _Tp* type;
-    };
-
-  /**
-   * Invoke a function object, which may be either a member pointer or a
-   * function object. The first parameter will tell which.
-   */
-  template<typename _Functor, typename... _Args>
-    inline
-    typename __gnu_cxx::__enable_if<
-             (!is_member_pointer<_Functor>::value
-              && !is_function<_Functor>::value
-              && !is_function<typename remove_pointer<_Functor>::type>::value),
-             typename result_of<_Functor(_Args...)>::type
-           >::__type
-    __invoke(_Functor& __f, _Args&... __args)
-    {
-      return __f(__args...);
-    }
-
-  template<typename _Functor, typename... _Args>
-    inline
-    typename __gnu_cxx::__enable_if<
-             (is_member_pointer<_Functor>::value
-              && !is_function<_Functor>::value
-              && !is_function<typename remove_pointer<_Functor>::type>::value),
-             typename result_of<_Functor(_Args...)>::type
-           >::__type
-    __invoke(_Functor& __f, _Args&... __args)
-    {
-      return mem_fn(__f)(__args...);
-    }
-
-  // To pick up function references (that will become function pointers)
-  template<typename _Functor, typename... _Args>
-    inline
-    typename __gnu_cxx::__enable_if<
-             (is_pointer<_Functor>::value
-              && is_function<typename remove_pointer<_Functor>::type>::value),
-             typename result_of<_Functor(_Args...)>::type
-           >::__type
-    __invoke(_Functor __f, _Args&... __args)
-    {
-      return __f(__args...);
-    }
-
-  /**
-   *  Knowing which of unary_function and binary_function _Tp derives
-   *  from, derives from the same and ensures that reference_wrapper
-   *  will have a weak result type. See cases below.
-   */
-  template<bool _Unary, bool _Binary, typename _Tp>
-    struct _Reference_wrapper_base_impl;
-
-  // Not a unary_function or binary_function, so try a weak result type.
-  template<typename _Tp>
-    struct _Reference_wrapper_base_impl<false, false, _Tp>
-    : _Weak_result_type<_Tp>
-    { };
-
-  // unary_function but not binary_function
-  template<typename _Tp>
-    struct _Reference_wrapper_base_impl<true, false, _Tp>
-    : unary_function<typename _Tp::argument_type,
-		     typename _Tp::result_type>
-    { };
-
-  // binary_function but not unary_function
-  template<typename _Tp>
-    struct _Reference_wrapper_base_impl<false, true, _Tp>
-    : binary_function<typename _Tp::first_argument_type,
-		      typename _Tp::second_argument_type,
-		      typename _Tp::result_type>
-    { };
-
-  // Both unary_function and binary_function. Import result_type to
-  // avoid conflicts.
-   template<typename _Tp>
-    struct _Reference_wrapper_base_impl<true, true, _Tp>
-    : unary_function<typename _Tp::argument_type,
-		     typename _Tp::result_type>,
-      binary_function<typename _Tp::first_argument_type,
-		      typename _Tp::second_argument_type,
-		      typename _Tp::result_type>
-    {
-      typedef typename _Tp::result_type result_type;
-    };
-
-  /**
-   *  Derives from unary_function or binary_function when it
-   *  can. Specializations handle all of the easy cases. The primary
-   *  template determines what to do with a class type, which may
-   *  derive from both unary_function and binary_function.
-  */
-  template<typename _Tp>
-    struct _Reference_wrapper_base
-    : _Reference_wrapper_base_impl<
-      _Derives_from_unary_function<_Tp>::value,
-      _Derives_from_binary_function<_Tp>::value,
-      _Tp>
-    { };
-
-  // - a function type (unary)
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res(_T1)>
-    : unary_function<_T1, _Res>
-    { };
-
-  // - a function type (binary)
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res(_T1, _T2)>
-    : binary_function<_T1, _T2, _Res>
-    { };
-
-  // - a function pointer type (unary)
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res(*)(_T1)>
-    : unary_function<_T1, _Res>
-    { };
-
-  // - a function pointer type (binary)
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
-    : binary_function<_T1, _T2, _Res>
-    { };
-
-  // - a pointer to member function type (unary, no qualifiers)
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res (_T1::*)()>
-    : unary_function<_T1*, _Res>
-    { };
-
-  // - a pointer to member function type (binary, no qualifiers)
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
-    : binary_function<_T1*, _T2, _Res>
-    { };
-
-  // - a pointer to member function type (unary, const)
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res (_T1::*)() const>
-    : unary_function<const _T1*, _Res>
-    { };
-
-  // - a pointer to member function type (binary, const)
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
-    : binary_function<const _T1*, _T2, _Res>
-    { };
-
-  // - a pointer to member function type (unary, volatile)
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
-    : unary_function<volatile _T1*, _Res>
-    { };
-
-  // - a pointer to member function type (binary, volatile)
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
-    : binary_function<volatile _T1*, _T2, _Res>
-    { };
-
-  // - a pointer to member function type (unary, const volatile)
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
-    : unary_function<const volatile _T1*, _Res>
-    { };
-
-  // - a pointer to member function type (binary, const volatile)
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
-    : binary_function<const volatile _T1*, _T2, _Res>
-    { };
-
-  /// reference_wrapper
-  template<typename _Tp>
-    class reference_wrapper
-    : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
-    {
-      // If _Tp is a function type, we can't form result_of<_Tp(...)>,
-      // so turn it into a function pointer type.
-      typedef typename _Function_to_function_pointer<_Tp>::type
-        _M_func_type;
-
-      _Tp* _M_data;
-    public:
-      typedef _Tp type;
-
-      explicit
-      reference_wrapper(_Tp& __indata): _M_data(&__indata)
-      { }
-
-      reference_wrapper(const reference_wrapper<_Tp>& __inref):
-      _M_data(__inref._M_data)
-      { }
-
-      reference_wrapper&
-      operator=(const reference_wrapper<_Tp>& __inref)
-      {
-        _M_data = __inref._M_data;
-        return *this;
-      }
-
-      operator _Tp&() const
-      { return this->get(); }
-
-      _Tp&
-      get() const
-      { return *_M_data; }
-
-      template<typename... _Args>
-        typename result_of<_M_func_type(_Args...)>::type
-        operator()(_Args&... __args) const
-        {
-	  return __invoke(get(), __args...);
-	}
-    };
-
-
-  // Denotes a reference should be taken to a variable.
-  template<typename _Tp>
-    inline reference_wrapper<_Tp>
-    ref(_Tp& __t)
-    { return reference_wrapper<_Tp>(__t); }
-
-  // Denotes a const reference should be taken to a variable.
-  template<typename _Tp>
-    inline reference_wrapper<const _Tp>
-    cref(const _Tp& __t)
-    { return reference_wrapper<const _Tp>(__t); }
-
-  template<typename _Tp>
-    inline reference_wrapper<_Tp>
-    ref(reference_wrapper<_Tp> __t)
-    { return ref(__t.get()); }
-
-  template<typename _Tp>
-    inline reference_wrapper<const _Tp>
-    cref(reference_wrapper<_Tp> __t)
-    { return cref(__t.get()); }
-
-  template<typename _Tp, bool>
-    struct _Mem_fn_const_or_non
-    {
-      typedef const _Tp& type;
-    };
-
-  template<typename _Tp>
-    struct _Mem_fn_const_or_non<_Tp, false>
-    {
-      typedef _Tp& type;
-    };
-
-  /**
-   * Derives from @c unary_function or @c binary_function, or perhaps
-   * nothing, depending on the number of arguments provided. The
-   * primary template is the basis case, which derives nothing.
-   */
-  template<typename _Res, typename... _ArgTypes> 
-    struct _Maybe_unary_or_binary_function { };
-
-  /// Derives from @c unary_function, as appropriate. 
-  template<typename _Res, typename _T1> 
-    struct _Maybe_unary_or_binary_function<_Res, _T1>
-    : std::unary_function<_T1, _Res> { };
-
-  /// Derives from @c binary_function, as appropriate. 
-  template<typename _Res, typename _T1, typename _T2> 
-    struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
-    : std::binary_function<_T1, _T2, _Res> { };
-
-  /// Implementation of @c mem_fn for member function pointers.
-  template<typename _Res, typename _Class, typename... _ArgTypes>
-    class _Mem_fn<_Res (_Class::*)(_ArgTypes...)>
-    : public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>
-    {
-      typedef _Res (_Class::*_Functor)(_ArgTypes...);
-
-      template<typename _Tp>
-        _Res
-        _M_call(_Tp& __object, const volatile _Class *, 
-                _ArgTypes... __args) const
-        { return (__object.*__pmf)(__args...); }
-
-      template<typename _Tp>
-        _Res
-        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
-        { return ((*__ptr).*__pmf)(__args...); }
-
-    public:
-      typedef _Res result_type;
-
-      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
-
-      // Handle objects
-      _Res
-      operator()(_Class& __object, _ArgTypes... __args) const
-      { return (__object.*__pmf)(__args...); }
-
-      // Handle pointers
-      _Res
-      operator()(_Class* __object, _ArgTypes... __args) const
-      { return (__object->*__pmf)(__args...); }
-
-      // Handle smart pointers, references and pointers to derived
-      template<typename _Tp>
-        _Res
-	operator()(_Tp& __object, _ArgTypes... __args) const
-        { return _M_call(__object, &__object, __args...); }
-
-    private:
-      _Functor __pmf;
-    };
-
-  /// Implementation of @c mem_fn for const member function pointers.
-  template<typename _Res, typename _Class, typename... _ArgTypes>
-    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const>
-    : public _Maybe_unary_or_binary_function<_Res, const _Class*, 
-					     _ArgTypes...>
-    {
-      typedef _Res (_Class::*_Functor)(_ArgTypes...) const;
-
-      template<typename _Tp>
-        _Res
-        _M_call(_Tp& __object, const volatile _Class *, 
-                _ArgTypes... __args) const
-        { return (__object.*__pmf)(__args...); }
-
-      template<typename _Tp>
-        _Res
-        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
-        { return ((*__ptr).*__pmf)(__args...); }
-
-    public:
-      typedef _Res result_type;
-
-      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
-
-      // Handle objects
-      _Res
-      operator()(const _Class& __object, _ArgTypes... __args) const
-      { return (__object.*__pmf)(__args...); }
-
-      // Handle pointers
-      _Res
-      operator()(const _Class* __object, _ArgTypes... __args) const
-      { return (__object->*__pmf)(__args...); }
-
-      // Handle smart pointers, references and pointers to derived
-      template<typename _Tp>
-        _Res operator()(_Tp& __object, _ArgTypes... __args) const
-        { return _M_call(__object, &__object, __args...); }
-
-    private:
-      _Functor __pmf;
-    };
-
-  /// Implementation of @c mem_fn for volatile member function pointers.
-  template<typename _Res, typename _Class, typename... _ArgTypes>
-    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile>
-    : public _Maybe_unary_or_binary_function<_Res, volatile _Class*, 
-					     _ArgTypes...>
-    {
-      typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile;
-
-      template<typename _Tp>
-        _Res
-        _M_call(_Tp& __object, const volatile _Class *, 
-                _ArgTypes... __args) const
-        { return (__object.*__pmf)(__args...); }
-
-      template<typename _Tp>
-        _Res
-        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
-        { return ((*__ptr).*__pmf)(__args...); }
-
-    public:
-      typedef _Res result_type;
-
-      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
-
-      // Handle objects
-      _Res
-      operator()(volatile _Class& __object, _ArgTypes... __args) const
-      { return (__object.*__pmf)(__args...); }
-
-      // Handle pointers
-      _Res
-      operator()(volatile _Class* __object, _ArgTypes... __args) const
-      { return (__object->*__pmf)(__args...); }
-
-      // Handle smart pointers, references and pointers to derived
-      template<typename _Tp>
-        _Res
-	operator()(_Tp& __object, _ArgTypes... __args) const
-        { return _M_call(__object, &__object, __args...); }
-
-    private:
-      _Functor __pmf;
-    };
-
-  /// Implementation of @c mem_fn for const volatile member function pointers.
-  template<typename _Res, typename _Class, typename... _ArgTypes>
-    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile>
-    : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*, 
-					     _ArgTypes...>
-    {
-      typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile;
-
-      template<typename _Tp>
-        _Res
-        _M_call(_Tp& __object, const volatile _Class *, 
-                _ArgTypes... __args) const
-        { return (__object.*__pmf)(__args...); }
-
-      template<typename _Tp>
-        _Res
-        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
-        { return ((*__ptr).*__pmf)(__args...); }
-
-    public:
-      typedef _Res result_type;
-
-      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
-
-      // Handle objects
-      _Res 
-      operator()(const volatile _Class& __object, _ArgTypes... __args) const
-      { return (__object.*__pmf)(__args...); }
-
-      // Handle pointers
-      _Res 
-      operator()(const volatile _Class* __object, _ArgTypes... __args) const
-      { return (__object->*__pmf)(__args...); }
-
-      // Handle smart pointers, references and pointers to derived
-      template<typename _Tp>
-        _Res operator()(_Tp& __object, _ArgTypes... __args) const
-        { return _M_call(__object, &__object, __args...); }
-
-    private:
-      _Functor __pmf;
-    };
-
-
-  template<typename _Res, typename _Class>
-    class _Mem_fn<_Res _Class::*>
-    {
-      // This bit of genius is due to Peter Dimov, improved slightly by
-      // Douglas Gregor.
-      template<typename _Tp>
-        _Res&
-        _M_call(_Tp& __object, _Class *) const
-        { return __object.*__pm; }
-
-      template<typename _Tp, typename _Up>
-        _Res&
-        _M_call(_Tp& __object, _Up * const *) const
-        { return (*__object).*__pm; }
-
-      template<typename _Tp, typename _Up>
-        const _Res&
-        _M_call(_Tp& __object, const _Up * const *) const
-        { return (*__object).*__pm; }
-
-      template<typename _Tp>
-        const _Res&
-        _M_call(_Tp& __object, const _Class *) const
-        { return __object.*__pm; }
-
-      template<typename _Tp>
-        const _Res&
-        _M_call(_Tp& __ptr, const volatile void*) const
-        { return (*__ptr).*__pm; }
-
-      template<typename _Tp> static _Tp& __get_ref();
-
-      template<typename _Tp>
-        static __sfinae_types::__one __check_const(_Tp&, _Class*);
-      template<typename _Tp, typename _Up>
-        static __sfinae_types::__one __check_const(_Tp&, _Up * const *);
-      template<typename _Tp, typename _Up>
-        static __sfinae_types::__two __check_const(_Tp&, const _Up * const *);
-      template<typename _Tp>
-        static __sfinae_types::__two __check_const(_Tp&, const _Class*);
-      template<typename _Tp>
-        static __sfinae_types::__two __check_const(_Tp&, const volatile void*);
-
-    public:
-      template<typename _Tp>
-        struct _Result_type
-	: _Mem_fn_const_or_non<_Res,
-	  (sizeof(__sfinae_types::__two)
-	   == sizeof(__check_const<_Tp>(__get_ref<_Tp>(), (_Tp*)0)))>
-        { };
-
-      template<typename _Signature>
-        struct result;
-
-      template<typename _CVMem, typename _Tp>
-        struct result<_CVMem(_Tp)>
-	: public _Result_type<_Tp> { };
-
-      template<typename _CVMem, typename _Tp>
-        struct result<_CVMem(_Tp&)>
-	: public _Result_type<_Tp> { };
-
-      explicit
-      _Mem_fn(_Res _Class::*__pm) : __pm(__pm) { }
-
-      // Handle objects
-      _Res&
-      operator()(_Class& __object) const
-      { return __object.*__pm; }
-
-      const _Res&
-      operator()(const _Class& __object) const
-      { return __object.*__pm; }
-
-      // Handle pointers
-      _Res&
-      operator()(_Class* __object) const
-      { return __object->*__pm; }
-
-      const _Res&
-      operator()(const _Class* __object) const
-      { return __object->*__pm; }
-
-      // Handle smart pointers and derived
-      template<typename _Tp>
-        typename _Result_type<_Tp>::type
-        operator()(_Tp& __unknown) const
-        { return _M_call(__unknown, &__unknown); }
-
-    private:
-      _Res _Class::*__pm;
-    };
-
-  /**
-   *  @brief Returns a function object that forwards to the member
-   *  pointer @a pm.
-   */
-  template<typename _Tp, typename _Class>
-    inline _Mem_fn<_Tp _Class::*>
-    mem_fn(_Tp _Class::* __pm)
-    {
-      return _Mem_fn<_Tp _Class::*>(__pm);
-    }
-
-  /**
-   *  @brief Determines if the given type _Tp is a function object
-   *  should be treated as a subexpression when evaluating calls to
-   *  function objects returned by bind(). [TR1 3.6.1]
-   */
-  template<typename _Tp>
-    struct is_bind_expression
-    { static const bool value = false; };
-
-  template<typename _Tp>
-    const bool is_bind_expression<_Tp>::value;
-
-  /**
-   *  @brief Determines if the given type _Tp is a placeholder in a
-   *  bind() expression and, if so, which placeholder it is. [TR1 3.6.2]
-   */
-  template<typename _Tp>
-    struct is_placeholder
-    { static const int value = 0; };
-
-  template<typename _Tp>
-    const int is_placeholder<_Tp>::value;
-
-  /// The type of placeholder objects defined by libstdc++.
-  template<int _Num> struct _Placeholder { };
-
-  /** @namespace std::placeholders
-   *  @brief ISO C++ 0x entities sub namespace for functional.
-   *
-   *  Define a large number of placeholders. There is no way to
-   *  simplify this with variadic templates, because we're introducing
-   *  unique names for each.
-   */
-  namespace placeholders 
-  { 
-    namespace 
-    {
-      _Placeholder<1> _1;
-      _Placeholder<2> _2;
-      _Placeholder<3> _3;
-      _Placeholder<4> _4;
-      _Placeholder<5> _5;
-      _Placeholder<6> _6;
-      _Placeholder<7> _7;
-      _Placeholder<8> _8;
-      _Placeholder<9> _9;
-      _Placeholder<10> _10;
-      _Placeholder<11> _11;
-      _Placeholder<12> _12;
-      _Placeholder<13> _13;
-      _Placeholder<14> _14;
-      _Placeholder<15> _15;
-      _Placeholder<16> _16;
-      _Placeholder<17> _17;
-      _Placeholder<18> _18;
-      _Placeholder<19> _19;
-      _Placeholder<20> _20;
-      _Placeholder<21> _21;
-      _Placeholder<22> _22;
-      _Placeholder<23> _23;
-      _Placeholder<24> _24;
-      _Placeholder<25> _25;
-      _Placeholder<26> _26;
-      _Placeholder<27> _27;
-      _Placeholder<28> _28;
-      _Placeholder<29> _29;
-    } 
-  }
-
-  /**
-   *  Partial specialization of is_placeholder that provides the placeholder
-   *  number for the placeholder objects defined by libstdc++.
-   */
-  template<int _Num>
-    struct is_placeholder<_Placeholder<_Num> >
-    { static const int value = _Num; };
-
-  template<int _Num>
-    const int is_placeholder<_Placeholder<_Num> >::value;
-
-  /**
-   * Stores a tuple of indices. Used by bind() to extract the elements
-   * in a tuple. 
-   */
-  template<int... _Indexes>
-    struct _Index_tuple { };
-
-  /// Builds an _Index_tuple<0, 1, 2, ..., _Num-1>.
-  template<std::size_t _Num, typename _Tuple = _Index_tuple<> >
-    struct _Build_index_tuple;
- 
-  template<std::size_t _Num, int... _Indexes> 
-    struct _Build_index_tuple<_Num, _Index_tuple<_Indexes...> >
-    : _Build_index_tuple<_Num - 1, 
-                         _Index_tuple<_Indexes..., sizeof...(_Indexes)> >
-    {
-    };
-
-  template<int... _Indexes>
-    struct _Build_index_tuple<0, _Index_tuple<_Indexes...> >
-    {
-      typedef _Index_tuple<_Indexes...> __type;
-    };
-
-  /** 
-   * Used by _Safe_tuple_element to indicate that there is no tuple
-   * element at this position.
-   */
-  struct _No_tuple_element;
-
-  /**
-   * Implementation helper for _Safe_tuple_element. This primary
-   * template handles the case where it is safe to use @c
-   * tuple_element.
-   */
-  template<int __i, typename _Tuple, bool _IsSafe>
-    struct _Safe_tuple_element_impl
-    : tuple_element<__i, _Tuple> { };
-
-  /**
-   * Implementation helper for _Safe_tuple_element. This partial
-   * specialization handles the case where it is not safe to use @c
-   * tuple_element. We just return @c _No_tuple_element.
-   */
-  template<int __i, typename _Tuple>
-    struct _Safe_tuple_element_impl<__i, _Tuple, false>
-    {
-      typedef _No_tuple_element type;
-    };
-
-  /**
-   * Like tuple_element, but returns @c _No_tuple_element when
-   * tuple_element would return an error.
-   */
- template<int __i, typename _Tuple>
-   struct _Safe_tuple_element
-   : _Safe_tuple_element_impl<__i, _Tuple, 
-                              (__i >= 0 && __i < tuple_size<_Tuple>::value)>
-   {
-   };
-
-  /**
-   *  Maps an argument to bind() into an actual argument to the bound
-   *  function object [TR1 3.6.3/5]. Only the first parameter should
-   *  be specified: the rest are used to determine among the various
-   *  implementations. Note that, although this class is a function
-   *  object, it isn't entirely normal because it takes only two
-   *  parameters regardless of the number of parameters passed to the
-   *  bind expression. The first parameter is the bound argument and
-   *  the second parameter is a tuple containing references to the
-   *  rest of the arguments.
-   */
-  template<typename _Arg,
-           bool _IsBindExp = is_bind_expression<_Arg>::value,
-           bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
-    class _Mu;
-
-  /**
-   *  If the argument is reference_wrapper<_Tp>, returns the
-   *  underlying reference. [TR1 3.6.3/5 bullet 1]
-   */
-  template<typename _Tp>
-    class _Mu<reference_wrapper<_Tp>, false, false>
-    {
-    public:
-      typedef _Tp& result_type;
-
-      /* Note: This won't actually work for const volatile
-       * reference_wrappers, because reference_wrapper::get() is const
-       * but not volatile-qualified. This might be a defect in the TR.
-       */
-      template<typename _CVRef, typename _Tuple>
-        result_type
-        operator()(_CVRef& __arg, const _Tuple&) const volatile
-        { return __arg.get(); }
-    };
-
-  /**
-   *  If the argument is a bind expression, we invoke the underlying
-   *  function object with the same cv-qualifiers as we are given and
-   *  pass along all of our arguments (unwrapped). [TR1 3.6.3/5 bullet 2]
-   */
-  template<typename _Arg>
-    class _Mu<_Arg, true, false>
-    {
-    public:
-      template<typename _Signature> class result;
-
-      // Determine the result type when we pass the arguments along. This
-      // involves passing along the cv-qualifiers placed on _Mu and
-      // unwrapping the argument bundle.
-      template<typename _CVMu, typename _CVArg, typename... _Args>
-        class result<_CVMu(_CVArg, tuple<_Args...>)>
-	: public result_of<_CVArg(_Args...)> { };
-
-      template<typename _CVArg, typename... _Args>
-        typename result_of<_CVArg(_Args...)>::type
-        operator()(_CVArg& __arg,
-		   const tuple<_Args...>& __tuple) const volatile
-        {
-	  // Construct an index tuple and forward to __call
-	  typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
-	    _Indexes;
-	  return this->__call(__arg, __tuple, _Indexes());
-	}
-
-    private:
-      // Invokes the underlying function object __arg by unpacking all
-      // of the arguments in the tuple. 
-      template<typename _CVArg, typename... _Args, int... _Indexes>
-        typename result_of<_CVArg(_Args...)>::type
-        __call(_CVArg& __arg, const tuple<_Args...>& __tuple,
-	       const _Index_tuple<_Indexes...>&) const volatile
-        {
-	  return __arg(_GLIBCXX_TR1 get<_Indexes>(__tuple)...);
-	}
-    };
-
-  /**
-   *  If the argument is a placeholder for the Nth argument, returns
-   *  a reference to the Nth argument to the bind function object.
-   *  [TR1 3.6.3/5 bullet 3]
-   */
-  template<typename _Arg>
-    class _Mu<_Arg, false, true>
-    {
-    public:
-      template<typename _Signature> class result;
-
-      template<typename _CVMu, typename _CVArg, typename _Tuple>
-        class result<_CVMu(_CVArg, _Tuple)>
-        {
-	  // Add a reference, if it hasn't already been done for us.
-	  // This allows us to be a little bit sloppy in constructing
-	  // the tuple that we pass to result_of<...>.
-	  typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value
-						- 1), _Tuple>::type
-	    __base_type;
-
-	public:
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-	  typedef typename add_lvalue_reference<__base_type>::type type;
-#else
-	  typedef typename add_reference<__base_type>::type type;
-#endif
-	};
-
-      template<typename _Tuple>
-        typename result<_Mu(_Arg, _Tuple)>::type
-        operator()(const volatile _Arg&, const _Tuple& __tuple) const volatile
-        {
-	  return ::std::_GLIBCXX_TR1 get<(is_placeholder<_Arg>::value
-					  - 1)>(__tuple);
-	}
-    };
-
-  /**
-   *  If the argument is just a value, returns a reference to that
-   *  value. The cv-qualifiers on the reference are the same as the
-   *  cv-qualifiers on the _Mu object. [TR1 3.6.3/5 bullet 4]
-   */
-  template<typename _Arg>
-    class _Mu<_Arg, false, false>
-    {
-    public:
-      template<typename _Signature> struct result;
-
-      template<typename _CVMu, typename _CVArg, typename _Tuple>
-        struct result<_CVMu(_CVArg, _Tuple)>
-        {
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-	  typedef typename add_lvalue_reference<_CVArg>::type type;
-#else
-	  typedef typename add_reference<_CVArg>::type type;
-#endif
-	};
-
-      // Pick up the cv-qualifiers of the argument
-      template<typename _CVArg, typename _Tuple>
-        _CVArg&
-        operator()(_CVArg& __arg, const _Tuple&) const volatile
-        { return __arg; }
-    };
-
-  /**
-   *  Maps member pointers into instances of _Mem_fn but leaves all
-   *  other function objects untouched. Used by tr1::bind(). The
-   *  primary template handles the non--member-pointer case.
-   */
-  template<typename _Tp>
-    struct _Maybe_wrap_member_pointer
-    {
-      typedef _Tp type;
-      
-      static const _Tp&
-      __do_wrap(const _Tp& __x)
-      { return __x; }
-    };
-
-  /**
-   *  Maps member pointers into instances of _Mem_fn but leaves all
-   *  other function objects untouched. Used by tr1::bind(). This
-   *  partial specialization handles the member pointer case.
-   */
-  template<typename _Tp, typename _Class>
-    struct _Maybe_wrap_member_pointer<_Tp _Class::*>
-    {
-      typedef _Mem_fn<_Tp _Class::*> type;
-      
-      static type
-      __do_wrap(_Tp _Class::* __pm)
-      { return type(__pm); }
-    };
-
-  /// Type of the function object returned from bind().
-  template<typename _Signature>
-    struct _Bind;
-
-   template<typename _Functor, typename... _Bound_args>
-    class _Bind<_Functor(_Bound_args...)>
-    : public _Weak_result_type<_Functor>
-    {
-      typedef _Bind __self_type;
-      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type 
-        _Bound_indexes;
-
-      _Functor _M_f;
-      tuple<_Bound_args...> _M_bound_args;
-
-      // Call unqualified
-      template<typename... _Args, int... _Indexes>
-        typename result_of<
-                   _Functor(typename result_of<_Mu<_Bound_args> 
-                            (_Bound_args, tuple<_Args...>)>::type...)
-                 >::type
-        __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>)
-        {
-          return _M_f(_Mu<_Bound_args>()
-                      (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
-        }
-
-      // Call as const
-      template<typename... _Args, int... _Indexes>
-        typename result_of<
-                   const _Functor(typename result_of<_Mu<_Bound_args> 
-                                    (const _Bound_args, tuple<_Args...>)
-                                  >::type...)>::type
-        __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const
-        {
-          return _M_f(_Mu<_Bound_args>()
-                      (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
-        }
-
-      // Call as volatile
-      template<typename... _Args, int... _Indexes>
-        typename result_of<
-                   volatile _Functor(typename result_of<_Mu<_Bound_args> 
-                                    (volatile _Bound_args, tuple<_Args...>)
-                                  >::type...)>::type
-        __call(const tuple<_Args...>& __args, 
-               _Index_tuple<_Indexes...>) volatile
-        {
-          return _M_f(_Mu<_Bound_args>()
-                      (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
-        }
-
-      // Call as const volatile
-      template<typename... _Args, int... _Indexes>
-        typename result_of<
-                   const volatile _Functor(typename result_of<_Mu<_Bound_args> 
-                                    (const volatile _Bound_args, 
-                                     tuple<_Args...>)
-                                  >::type...)>::type
-        __call(const tuple<_Args...>& __args, 
-               _Index_tuple<_Indexes...>) const volatile
-        {
-          return _M_f(_Mu<_Bound_args>()
-                      (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
-        }
-
-     public:
-      explicit _Bind(_Functor __f, _Bound_args... __bound_args)
-        : _M_f(__f), _M_bound_args(__bound_args...) { }
-
-      // Call unqualified
-      template<typename... _Args>
-        typename result_of<
-                   _Functor(typename result_of<_Mu<_Bound_args> 
-                            (_Bound_args, tuple<_Args...>)>::type...)
-                 >::type
-        operator()(_Args&... __args)
-        {
-          return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
-        }
-
-      // Call as const
-      template<typename... _Args>
-        typename result_of<
-                   const _Functor(typename result_of<_Mu<_Bound_args> 
-                            (const _Bound_args, tuple<_Args...>)>::type...)
-                 >::type
-        operator()(_Args&... __args) const
-        {
-          return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
-        }
-
-
-      // Call as volatile
-      template<typename... _Args>
-        typename result_of<
-                   volatile _Functor(typename result_of<_Mu<_Bound_args> 
-                            (volatile _Bound_args, tuple<_Args...>)>::type...)
-                 >::type
-        operator()(_Args&... __args) volatile
-        {
-          return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
-        }
-
-
-      // Call as const volatile
-      template<typename... _Args>
-        typename result_of<
-                   const volatile _Functor(typename result_of<_Mu<_Bound_args> 
-                            (const volatile _Bound_args, 
-                             tuple<_Args...>)>::type...)
-                 >::type
-        operator()(_Args&... __args) const volatile
-        {
-          return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
-        }
-    };
-
-  /// Type of the function object returned from bind<R>().
-  template<typename _Result, typename _Signature>
-    struct _Bind_result;
-
-  template<typename _Result, typename _Functor, typename... _Bound_args>
-    class _Bind_result<_Result, _Functor(_Bound_args...)>
-    {
-      typedef _Bind_result __self_type;
-      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type 
-        _Bound_indexes;
-
-      _Functor _M_f;
-      tuple<_Bound_args...> _M_bound_args;
-
-      // Call unqualified
-      template<typename... _Args, int... _Indexes>
-        _Result
-        __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>)
-        {
-          return _M_f(_Mu<_Bound_args>()
-                      (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
-        }
-
-      // Call as const
-      template<typename... _Args, int... _Indexes>
-        _Result
-        __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const
-        {
-          return _M_f(_Mu<_Bound_args>()
-                      (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
-        }
-
-      // Call as volatile
-      template<typename... _Args, int... _Indexes>
-        _Result
-        __call(const tuple<_Args...>& __args, 
-               _Index_tuple<_Indexes...>) volatile
-        {
-          return _M_f(_Mu<_Bound_args>()
-                      (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
-        }
-
-      // Call as const volatile
-      template<typename... _Args, int... _Indexes>
-        _Result
-        __call(const tuple<_Args...>& __args, 
-               _Index_tuple<_Indexes...>) const volatile
-        {
-          return _M_f(_Mu<_Bound_args>()
-                      (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
-        }
-
-    public:
-      typedef _Result result_type;
-
-      explicit
-      _Bind_result(_Functor __f, _Bound_args... __bound_args)
-      : _M_f(__f), _M_bound_args(__bound_args...) { }
-
-      // Call unqualified
-      template<typename... _Args>
-        result_type
-        operator()(_Args&... __args)
-        {
-          return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
-        }
-
-      // Call as const
-      template<typename... _Args>
-        result_type
-        operator()(_Args&... __args) const
-        {
-          return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
-        }
-
-      // Call as volatile
-      template<typename... _Args>
-        result_type
-        operator()(_Args&... __args) volatile
-        {
-          return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
-        }
-
-      // Call as const volatile
-      template<typename... _Args>
-        result_type
-        operator()(_Args&... __args) const volatile
-        {
-          return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
-        }
-    };
-
-  /// Class template _Bind is always a bind expression.
-  template<typename _Signature>
-    struct is_bind_expression<_Bind<_Signature> >
-    { static const bool value = true; };
-
-  template<typename _Signature>
-    const bool is_bind_expression<_Bind<_Signature> >::value;
-
-  /// Class template _Bind_result is always a bind expression.
-  template<typename _Result, typename _Signature>
-    struct is_bind_expression<_Bind_result<_Result, _Signature> >
-    { static const bool value = true; };
-
-  template<typename _Result, typename _Signature>
-    const bool is_bind_expression<_Bind_result<_Result, _Signature> >::value;
-
-  /// bind
-  template<typename _Functor, typename... _ArgTypes>
-    inline
-    _Bind<typename _Maybe_wrap_member_pointer<_Functor>::type(_ArgTypes...)>
-    bind(_Functor __f, _ArgTypes... __args)
-    {
-      typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type;
-      typedef typename __maybe_type::type __functor_type;
-      typedef _Bind<__functor_type(_ArgTypes...)> __result_type;
-      return __result_type(__maybe_type::__do_wrap(__f), __args...);
-    } 
-
-  template<typename _Result, typename _Functor, typename... _ArgTypes>
-    inline
-    _Bind_result<_Result,
-		 typename _Maybe_wrap_member_pointer<_Functor>::type
-                            (_ArgTypes...)>
-    bind(_Functor __f, _ArgTypes... __args)
-    {
-      typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type;
-      typedef typename __maybe_type::type __functor_type;
-      typedef _Bind_result<_Result, __functor_type(_ArgTypes...)>
-	__result_type;
-      return __result_type(__maybe_type::__do_wrap(__f), __args...);
-    }
-
-  /**
-   *  @brief Exception class thrown when class template function's
-   *  operator() is called with an empty target.
-   *
-   */
-  class bad_function_call : public std::exception { };
-
-  /**
-   *  The integral constant expression 0 can be converted into a
-   *  pointer to this type. It is used by the function template to
-   *  accept NULL pointers.
-   */
-  struct _M_clear_type;
-
-  /**
-   *  Trait identifying "location-invariant" types, meaning that the
-   *  address of the object (or any of its members) will not escape.
-   *  Also implies a trivial copy constructor and assignment operator.
-   */
-  template<typename _Tp>
-    struct __is_location_invariant
-    : integral_constant<bool,
-                        (is_pointer<_Tp>::value
-                         || is_member_pointer<_Tp>::value)>
-    {
-    };
-
-  class _Undefined_class;
-
-  union _Nocopy_types
-  {
-    void*       _M_object;
-    const void* _M_const_object;
-    void (*_M_function_pointer)();
-    void (_Undefined_class::*_M_member_pointer)();
-  };
-
-  union _Any_data
-  {
-    void*       _M_access()       { return &_M_pod_data[0]; }
-    const void* _M_access() const { return &_M_pod_data[0]; }
-
-    template<typename _Tp>
-      _Tp&
-      _M_access()
-      { return *static_cast<_Tp*>(_M_access()); }
-
-    template<typename _Tp>
-      const _Tp&
-      _M_access() const
-      { return *static_cast<const _Tp*>(_M_access()); }
-
-    _Nocopy_types _M_unused;
-    char _M_pod_data[sizeof(_Nocopy_types)];
-  };
-
-  enum _Manager_operation
-  {
-    __get_type_info,
-    __get_functor_ptr,
-    __clone_functor,
-    __destroy_functor
-  };
-
-  // Simple type wrapper that helps avoid annoying const problems
-  // when casting between void pointers and pointers-to-pointers.
-  template<typename _Tp>
-    struct _Simple_type_wrapper
-    {
-      _Simple_type_wrapper(_Tp __value) : __value(__value) { }
-
-      _Tp __value;
-    };
-
-  template<typename _Tp>
-    struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
-    : __is_location_invariant<_Tp>
-    {
-    };
-
-  // Converts a reference to a function object into a callable
-  // function object.
-  template<typename _Functor>
-    inline _Functor&
-    __callable_functor(_Functor& __f)
-    { return __f; }
-
-  template<typename _Member, typename _Class>
-    inline _Mem_fn<_Member _Class::*>
-    __callable_functor(_Member _Class::* &__p)
-    { return mem_fn(__p); }
-
-  template<typename _Member, typename _Class>
-    inline _Mem_fn<_Member _Class::*>
-    __callable_functor(_Member _Class::* const &__p)
-    { return mem_fn(__p); }
-
-  template<typename _Signature>
-    class function;
-
-  /// Base class of all polymorphic function object wrappers.
-  class _Function_base
-  {
-  public:
-    static const std::size_t _M_max_size = sizeof(_Nocopy_types);
-    static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
-
-    template<typename _Functor>
-      class _Base_manager
-      {
-      protected:
-	static const bool __stored_locally =
-        (__is_location_invariant<_Functor>::value
-         && sizeof(_Functor) <= _M_max_size
-         && __alignof__(_Functor) <= _M_max_align
-         && (_M_max_align % __alignof__(_Functor) == 0));
-	
-	typedef integral_constant<bool, __stored_locally> _Local_storage;
-
-	// Retrieve a pointer to the function object
-	static _Functor*
-	_M_get_pointer(const _Any_data& __source)
-	{
-	  const _Functor* __ptr =
-	    __stored_locally? &__source._M_access<_Functor>()
-	    /* have stored a pointer */ : __source._M_access<_Functor*>();
-	  return const_cast<_Functor*>(__ptr);
-	}
-
-	// Clone a location-invariant function object that fits within
-	// an _Any_data structure.
-	static void
-	_M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
-	{
-	  new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
-	}
-
-	// Clone a function object that is not location-invariant or
-	// that cannot fit into an _Any_data structure.
-	static void
-	_M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
-	{
-	  __dest._M_access<_Functor*>() =
-	    new _Functor(*__source._M_access<_Functor*>());
-	}
-
-	// Destroying a location-invariant object may still require
-	// destruction.
-	static void
-	_M_destroy(_Any_data& __victim, true_type)
-	{
-	  __victim._M_access<_Functor>().~_Functor();
-	}
-	
-	// Destroying an object located on the heap.
-	static void
-	_M_destroy(_Any_data& __victim, false_type)
-	{
-	  delete __victim._M_access<_Functor*>();
-	}
-	
-      public:
-	static bool
-	_M_manager(_Any_data& __dest, const _Any_data& __source,
-		   _Manager_operation __op)
-	{
-	  switch (__op)
-	    {
-#ifdef __GXX_RTTI
-	    case __get_type_info:
-	      __dest._M_access<const type_info*>() = &typeid(_Functor);
-	      break;
-#endif
-	    case __get_functor_ptr:
-	      __dest._M_access<_Functor*>() = _M_get_pointer(__source);
-	      break;
-	      
-	    case __clone_functor:
-	      _M_clone(__dest, __source, _Local_storage());
-	      break;
-
-	    case __destroy_functor:
-	      _M_destroy(__dest, _Local_storage());
-	      break;
-	    }
-	  return false;
-	}
-
-	static void
-	_M_init_functor(_Any_data& __functor, const _Functor& __f)
-	{ _M_init_functor(__functor, __f, _Local_storage()); }
-	
-	template<typename _Signature>
-	  static bool
-	  _M_not_empty_function(const function<_Signature>& __f)
-	  { return __f; }
-
-	template<typename _Tp>
-	  static bool
-	  _M_not_empty_function(const _Tp*& __fp)
-	  { return __fp; }
-
-	template<typename _Class, typename _Tp>
-	  static bool
-	  _M_not_empty_function(_Tp _Class::* const& __mp)
-	  { return __mp; }
-
-	template<typename _Tp>
-	  static bool
-	  _M_not_empty_function(const _Tp&)
-	  { return true; }
-
-      private:
-	static void
-	_M_init_functor(_Any_data& __functor, const _Functor& __f, true_type)
-	{ new (__functor._M_access()) _Functor(__f); }
-
-	static void
-	_M_init_functor(_Any_data& __functor, const _Functor& __f, false_type)
-	{ __functor._M_access<_Functor*>() = new _Functor(__f); }
-      };
-
-    template<typename _Functor>
-      class _Ref_manager : public _Base_manager<_Functor*>
-      {
-	typedef _Function_base::_Base_manager<_Functor*> _Base;
-
-    public:
-	static bool
-	_M_manager(_Any_data& __dest, const _Any_data& __source,
-		   _Manager_operation __op)
-	{
-	  switch (__op)
-	    {
-#ifdef __GXX_RTTI
-	    case __get_type_info:
-	      __dest._M_access<const type_info*>() = &typeid(_Functor);
-	      break;
-#endif
-	    case __get_functor_ptr:
-	      __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
-	      return is_const<_Functor>::value;
-	      break;
-	      
-	    default:
-	      _Base::_M_manager(__dest, __source, __op);
-	    }
-	  return false;
-	}
-
-	static void
-	_M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
-	{
-	  // TBD: Use address_of function instead.
-	  _Base::_M_init_functor(__functor, &__f.get());
-	}
-      };
-
-    _Function_base() : _M_manager(0) { }
-    
-    ~_Function_base()
-    {
-      if (_M_manager)
-	_M_manager(_M_functor, _M_functor, __destroy_functor);
-    }
-
-
-    bool _M_empty() const { return !_M_manager; }
-
-    typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
-                                  _Manager_operation);
-
-    _Any_data     _M_functor;
-    _Manager_type _M_manager;
-  };
-
-  template<typename _Signature, typename _Functor>
-    class _Function_handler;
-
-  template<typename _Res, typename _Functor, typename... _ArgTypes>
-    class _Function_handler<_Res(_ArgTypes...), _Functor>
-    : public _Function_base::_Base_manager<_Functor>
-    {
-      typedef _Function_base::_Base_manager<_Functor> _Base;
-
-    public:
-      static _Res
-      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
-      {
-        return (*_Base::_M_get_pointer(__functor))(__args...);
-      }
-    };
-
-  template<typename _Functor, typename... _ArgTypes>
-    class _Function_handler<void(_ArgTypes...), _Functor>
-    : public _Function_base::_Base_manager<_Functor>
-    {
-      typedef _Function_base::_Base_manager<_Functor> _Base;
-
-     public:
-      static void
-      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
-      {
-        (*_Base::_M_get_pointer(__functor))(__args...);
-      }
-    };
-
-  template<typename _Res, typename _Functor, typename... _ArgTypes>
-    class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
-    : public _Function_base::_Ref_manager<_Functor>
-    {
-      typedef _Function_base::_Ref_manager<_Functor> _Base;
-
-     public:
-      static _Res
-      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
-      {
-        return 
-          __callable_functor(**_Base::_M_get_pointer(__functor))(__args...);
-      }
-    };
-
-  template<typename _Functor, typename... _ArgTypes>
-    class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
-    : public _Function_base::_Ref_manager<_Functor>
-    {
-      typedef _Function_base::_Ref_manager<_Functor> _Base;
-
-     public:
-      static void
-      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
-      {
-        __callable_functor(**_Base::_M_get_pointer(__functor))(__args...);
-      }
-    };
-
-  template<typename _Class, typename _Member, typename _Res, 
-           typename... _ArgTypes>
-    class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
-    : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
-    {
-      typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
-        _Base;
-
-     public:
-      static _Res
-      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
-      {
-        return _GLIBCXX_TR1
-	  mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...);
-      }
-    };
-
-  template<typename _Class, typename _Member, typename... _ArgTypes>
-    class _Function_handler<void(_ArgTypes...), _Member _Class::*>
-    : public _Function_base::_Base_manager<
-                 _Simple_type_wrapper< _Member _Class::* > >
-    {
-      typedef _Member _Class::* _Functor;
-      typedef _Simple_type_wrapper<_Functor> _Wrapper;
-      typedef _Function_base::_Base_manager<_Wrapper> _Base;
-
-     public:
-      static bool
-      _M_manager(_Any_data& __dest, const _Any_data& __source,
-                 _Manager_operation __op)
-      {
-        switch (__op)
-	  {
-#ifdef __GXX_RTTI
-	  case __get_type_info:
-	    __dest._M_access<const type_info*>() = &typeid(_Functor);
-	    break;
-#endif	    
-	  case __get_functor_ptr:
-	    __dest._M_access<_Functor*>() =
-	      &_Base::_M_get_pointer(__source)->__value;
-	    break;
-	    
-	  default:
-	    _Base::_M_manager(__dest, __source, __op);
-	  }
-        return false;
-      }
-
-      static void
-      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
-      {
-        _GLIBCXX_TR1
-	  mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...);
-      }
-    };
-
-  /// class function
-  template<typename _Res, typename... _ArgTypes>
-    class function<_Res(_ArgTypes...)>
-    : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
-      private _Function_base
-    {
-      /// This class is used to implement the safe_bool idiom.
-      struct _Hidden_type
-      {
-	_Hidden_type* _M_bool;
-      };
-
-      /// This typedef is used to implement the safe_bool idiom.
-      typedef _Hidden_type* _Hidden_type::* _Safe_bool;
-
-      typedef _Res _Signature_type(_ArgTypes...);
-      
-      struct _Useless { };
-      
-    public:
-      typedef _Res result_type;
-      
-      // [3.7.2.1] construct/copy/destroy
-      
-      /**
-       *  @brief Default construct creates an empty function call wrapper.
-       *  @post @c !(bool)*this
-       */
-      function() : _Function_base() { }
-      
-      /**
-       *  @brief Default construct creates an empty function call wrapper.
-       *  @post @c !(bool)*this
-       */
-      function(_M_clear_type*) : _Function_base() { }
-      
-      /**
-       *  @brief %Function copy constructor.
-       *  @param x A %function object with identical call signature.
-       *  @pre @c (bool)*this == (bool)x
-       *
-       *  The newly-created %function contains a copy of the target of @a
-       *  x (if it has one).
-       */
-      function(const function& __x);
-      
-      /**
-       *  @brief Builds a %function that targets a copy of the incoming
-       *  function object.
-       *  @param f A %function object that is callable with parameters of
-       *  type @c T1, @c T2, ..., @c TN and returns a value convertible
-       *  to @c Res.
-       *
-       *  The newly-created %function object will target a copy of @a
-       *  f. If @a f is @c reference_wrapper<F>, then this function
-       *  object will contain a reference to the function object @c
-       *  f.get(). If @a f is a NULL function pointer or NULL
-       *  pointer-to-member, the newly-created object will be empty.
-       *
-       *  If @a f is a non-NULL function pointer or an object of type @c
-       *  reference_wrapper<F>, this function will not throw.
-       */
-      template<typename _Functor>
-        function(_Functor __f,
-                 typename __gnu_cxx::__enable_if<
-                           !is_integral<_Functor>::value, _Useless>::__type
-                   = _Useless());
-
-      /**
-       *  @brief %Function assignment operator.
-       *  @param x A %function with identical call signature.
-       *  @post @c (bool)*this == (bool)x
-       *  @returns @c *this
-       *
-       *  The target of @a x is copied to @c *this. If @a x has no
-       *  target, then @c *this will be empty.
-       *
-       *  If @a x targets a function pointer or a reference to a function
-       *  object, then this operation will not throw an exception.
-       */
-      function&
-      operator=(const function& __x)
-      {
-        function(__x).swap(*this);
-        return *this;
-      }
-
-      /**
-       *  @brief %Function assignment to zero.
-       *  @post @c !(bool)*this
-       *  @returns @c *this
-       *
-       *  The target of @a *this is deallocated, leaving it empty.
-       */
-      function&
-      operator=(_M_clear_type*)
-      {
-        if (_M_manager)
-	  {
-	    _M_manager(_M_functor, _M_functor, __destroy_functor);
-	    _M_manager = 0;
-	    _M_invoker = 0;
-	  }
-        return *this;
-      }
-
-      /**
-       *  @brief %Function assignment to a new target.
-       *  @param f A %function object that is callable with parameters of
-       *  type @c T1, @c T2, ..., @c TN and returns a value convertible
-       *  to @c Res.
-       *  @return @c *this
-       *
-       *  This  %function object wrapper will target a copy of @a
-       *  f. If @a f is @c reference_wrapper<F>, then this function
-       *  object will contain a reference to the function object @c
-       *  f.get(). If @a f is a NULL function pointer or NULL
-       *  pointer-to-member, @c this object will be empty.
-       *
-       *  If @a f is a non-NULL function pointer or an object of type @c
-       *  reference_wrapper<F>, this function will not throw.
-       */
-      template<typename _Functor>
-        typename __gnu_cxx::__enable_if<!is_integral<_Functor>::value,
-	                                function&>::__type
-	operator=(_Functor __f)
-	{
-	  function(__f).swap(*this);
-	  return *this;
-	}
-
-      // [3.7.2.2] function modifiers
-      
-      /**
-       *  @brief Swap the targets of two %function objects.
-       *  @param f A %function with identical call signature.
-       *
-       *  Swap the targets of @c this function object and @a f. This
-       *  function will not throw an exception.
-       */
-      void swap(function& __x)
-      {
-	_Any_data __old_functor = _M_functor;
-	_M_functor = __x._M_functor;
-	__x._M_functor = __old_functor;
-	_Manager_type __old_manager = _M_manager;
-	_M_manager = __x._M_manager;
-	__x._M_manager = __old_manager;
-	_Invoker_type __old_invoker = _M_invoker;
-	_M_invoker = __x._M_invoker;
-	__x._M_invoker = __old_invoker;
-      }
-      
-      // [3.7.2.3] function capacity
-
-      /**
-       *  @brief Determine if the %function wrapper has a target.
-       *
-       *  @return @c true when this %function object contains a target,
-       *  or @c false when it is empty.
-       *
-       *  This function will not throw an exception.
-       */
-      operator _Safe_bool() const
-      {
-        if (_M_empty())
-	  return 0;
-	else
-	  return &_Hidden_type::_M_bool;
-      }
-
-      // [3.7.2.4] function invocation
-
-      /**
-       *  @brief Invokes the function targeted by @c *this.
-       *  @returns the result of the target.
-       *  @throws bad_function_call when @c !(bool)*this
-       *
-       *  The function call operator invokes the target function object
-       *  stored by @c this.
-       */
-      _Res operator()(_ArgTypes... __args) const;
-
-#ifdef __GXX_RTTI
-      // [3.7.2.5] function target access
-      /**
-       *  @brief Determine the type of the target of this function object
-       *  wrapper.
-       *
-       *  @returns the type identifier of the target function object, or
-       *  @c typeid(void) if @c !(bool)*this.
-       *
-       *  This function will not throw an exception.
-       */
-      const type_info& target_type() const;
-      
-      /**
-       *  @brief Access the stored target function object.
-       *
-       *  @return Returns a pointer to the stored target function object,
-       *  if @c typeid(Functor).equals(target_type()); otherwise, a NULL
-       *  pointer.
-       *
-       * This function will not throw an exception.
-       */
-      template<typename _Functor>       _Functor* target();
-      
-      /// @overload
-      template<typename _Functor> const _Functor* target() const;
-#endif
-
-    private:
-      // [3.7.2.6] undefined operators
-      template<typename _Function>
-	void operator==(const function<_Function>&) const;
-      template<typename _Function>
-	void operator!=(const function<_Function>&) const;
-
-      typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...);
-      _Invoker_type _M_invoker;
-  };
-
-  template<typename _Res, typename... _ArgTypes>
-    function<_Res(_ArgTypes...)>::
-    function(const function& __x)
-    : _Function_base()
-    {
-      if (__x)
-	{
-	  _M_invoker = __x._M_invoker;
-	  _M_manager = __x._M_manager;
-	  __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
-	}
-    }
-
-  template<typename _Res, typename... _ArgTypes>
-    template<typename _Functor>
-      function<_Res(_ArgTypes...)>::
-      function(_Functor __f,
-	       typename __gnu_cxx::__enable_if<
-                       !is_integral<_Functor>::value, _Useless>::__type)
-      : _Function_base()
-      {
-	typedef _Function_handler<_Signature_type, _Functor> _My_handler;
-
-	if (_My_handler::_M_not_empty_function(__f))
-	  {
-	    _M_invoker = &_My_handler::_M_invoke;
-	    _M_manager = &_My_handler::_M_manager;
-	    _My_handler::_M_init_functor(_M_functor, __f);
-	  }
-      }
-
-  template<typename _Res, typename... _ArgTypes>
-    _Res
-    function<_Res(_ArgTypes...)>::
-    operator()(_ArgTypes... __args) const
-    {
-      if (_M_empty())
-        {
-#if __EXCEPTIONS
-          throw bad_function_call();
-#else
-          __builtin_abort();
-#endif
-        }
-      return _M_invoker(_M_functor, __args...);
-    }
-
-#ifdef __GXX_RTTI
-  template<typename _Res, typename... _ArgTypes>
-    const type_info&
-    function<_Res(_ArgTypes...)>::
-    target_type() const
-    {
-      if (_M_manager)
-        {
-          _Any_data __typeinfo_result;
-          _M_manager(__typeinfo_result, _M_functor, __get_type_info);
-          return *__typeinfo_result._M_access<const type_info*>();
-        }
-      else
-	return typeid(void);
-    }
-
-  template<typename _Res, typename... _ArgTypes>
-    template<typename _Functor>
-      _Functor*
-      function<_Res(_ArgTypes...)>::
-      target()
-      {
-	if (typeid(_Functor) == target_type() && _M_manager)
-	  {
-	    _Any_data __ptr;
-	    if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
-		&& !is_const<_Functor>::value)
-	      return 0;
-	    else
-	      return __ptr._M_access<_Functor*>();
-	  }
-	else
-	  return 0;
-      }
-
-  template<typename _Res, typename... _ArgTypes>
-    template<typename _Functor>
-      const _Functor*
-      function<_Res(_ArgTypes...)>::
-      target() const
-      {
-	if (typeid(_Functor) == target_type() && _M_manager)
-	  {
-	    _Any_data __ptr;
-	    _M_manager(__ptr, _M_functor, __get_functor_ptr);
-	    return __ptr._M_access<const _Functor*>();
-	  }
-	else
-	  return 0;
-      }
-#endif
-
-  // [3.7.2.7] null pointer comparisons
-
-  /**
-   *  @brief Compares a polymorphic function object wrapper against 0
-   *  (the NULL pointer).
-   *  @returns @c true if the wrapper has no target, @c false otherwise
-   *
-   *  This function will not throw an exception.
-   */
-  template<typename _Signature>
-    inline bool
-    operator==(const function<_Signature>& __f, _M_clear_type*)
-    { return !__f; }
-
-  /// @overload
-  template<typename _Signature>
-    inline bool
-    operator==(_M_clear_type*, const function<_Signature>& __f)
-    { return !__f; }
-
-  /**
-   *  @brief Compares a polymorphic function object wrapper against 0
-   *  (the NULL pointer).
-   *  @returns @c false if the wrapper has no target, @c true otherwise
-   *
-   *  This function will not throw an exception.
-   */
-  template<typename _Signature>
-    inline bool
-    operator!=(const function<_Signature>& __f, _M_clear_type*)
-    { return __f; }
-
-  /// @overload
-  template<typename _Signature>
-    inline bool
-    operator!=(_M_clear_type*, const function<_Signature>& __f)
-    { return __f; }
-
-  // [3.7.2.8] specialized algorithms
-
-  /**
-   *  @brief Swap the targets of two polymorphic function object wrappers.
-   *
-   *  This function will not throw an exception.
-   */
-  template<typename _Signature>
-    inline void
-    swap(function<_Signature>& __x, function<_Signature>& __y)
-    { __x.swap(__y); }
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/functional_hash.h b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/functional_hash.h
deleted file mode 100644
index 665168c0f..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/functional_hash.h
+++ /dev/null
@@ -1,183 +0,0 @@
-// TR1 functional -*- C++ -*-
-
-// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/functional_hash.h
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-  /// Class template hash.
-  // Declaration of default hash functor std::tr1::hash.  The types for
-  // which std::tr1::hash<T> is well-defined is in clause 6.3.3. of the PDTR.
-  template<typename _Tp>
-    struct hash : public std::unary_function<_Tp, size_t>
-    {
-      size_t
-      operator()(_Tp __val) const;
-    };
-
-  /// Partial specializations for pointer types.
-  template<typename _Tp>
-    struct hash<_Tp*> : public std::unary_function<_Tp*, size_t>
-    {
-      size_t
-      operator()(_Tp* __p) const
-      { return reinterpret_cast<size_t>(__p); }
-    };
-
-  /// Explicit specializations for integer types.
-#define _TR1_hashtable_define_trivial_hash(_Tp) 	\
-  template<>						\
-    inline size_t					\
-    hash<_Tp>::operator()(_Tp __val) const		\
-    { return static_cast<size_t>(__val); }
-
-  _TR1_hashtable_define_trivial_hash(bool);
-  _TR1_hashtable_define_trivial_hash(char);
-  _TR1_hashtable_define_trivial_hash(signed char);
-  _TR1_hashtable_define_trivial_hash(unsigned char);
-  _TR1_hashtable_define_trivial_hash(wchar_t);
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-  _TR1_hashtable_define_trivial_hash(char16_t);
-  _TR1_hashtable_define_trivial_hash(char32_t);
-#endif
-  _TR1_hashtable_define_trivial_hash(short);
-  _TR1_hashtable_define_trivial_hash(int);
-  _TR1_hashtable_define_trivial_hash(long);
-  _TR1_hashtable_define_trivial_hash(long long);
-  _TR1_hashtable_define_trivial_hash(unsigned short);
-  _TR1_hashtable_define_trivial_hash(unsigned int);
-  _TR1_hashtable_define_trivial_hash(unsigned long);
-  _TR1_hashtable_define_trivial_hash(unsigned long long);
-
-#undef _TR1_hashtable_define_trivial_hash
-
-  // Fowler / Noll / Vo (FNV) Hash (type FNV-1a)
-  // (Used by the next specializations of std::tr1::hash.)
-
-  /// Dummy generic implementation (for sizeof(size_t) != 4, 8).
-  template<size_t = sizeof(size_t)>
-    struct _Fnv_hash
-    {
-      static size_t
-      hash(const char* __first, size_t __length)
-      {
-	size_t __result = 0;
-	for (; __length > 0; --__length)
-	  __result = (__result * 131) + *__first++;
-	return __result;
-      }
-    };
-
-  template<>
-    struct _Fnv_hash<4>
-    {
-      static size_t
-      hash(const char* __first, size_t __length)
-      {
-	size_t __result = static_cast<size_t>(2166136261UL);
-	for (; __length > 0; --__length)
-	  {
-	    __result ^= static_cast<size_t>(*__first++);
-	    __result *= static_cast<size_t>(16777619UL);
-	  }
-	return __result;
-      }
-    };
-  
-  template<>
-    struct _Fnv_hash<8>
-    {
-      static size_t
-      hash(const char* __first, size_t __length)
-      {
-	size_t __result =
-	  static_cast<size_t>(14695981039346656037ULL);
-	for (; __length > 0; --__length)
-	  {
-	    __result ^= static_cast<size_t>(*__first++);
-	    __result *= static_cast<size_t>(1099511628211ULL);
-	  }
-	return __result;
-      }
-    };
-
-  /// Explicit specializations for float.
-  template<>
-    inline size_t
-    hash<float>::operator()(float __val) const
-    {
-      size_t __result = 0;
-      
-      // 0 and -0 both hash to zero.
-      if (__val != 0.0f)
-	__result = _Fnv_hash<>::hash(reinterpret_cast<const char*>(&__val),
-				     sizeof(__val));
-      return __result;
-    };
-
-  /// Explicit specializations for double.
-  template<>
-    inline size_t
-    hash<double>::operator()(double __val) const
-    {
-	size_t __result = 0;
-
-	// 0 and -0 both hash to zero.
-	if (__val != 0.0)
-	  __result = _Fnv_hash<>::hash(reinterpret_cast<const char*>(&__val),
-				       sizeof(__val));
-	return __result;
-    };
-
-  /// Explicit specializations for long double.
-  template<>
-    size_t
-    hash<long double>::operator()(long double __val) const;
-
-  /// Explicit specialization of member operator for non-builtin types.
-  template<>
-    size_t
-    hash<string>::operator()(string) const;
-
-  template<>
-    size_t
-    hash<const string&>::operator()(const string&) const;
-
-#ifdef _GLIBCXX_USE_WCHAR_T
-  template<>
-    size_t
-    hash<wstring>::operator()(wstring) const;
-
-  template<>
-    size_t
-    hash<const wstring&>::operator()(const wstring&) const;
-#endif
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/hashtable b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/hashtable
deleted file mode 100644
index bce550ff1..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/hashtable
+++ /dev/null
@@ -1,1258 +0,0 @@
-// Internal header for TR1 unordered_set and unordered_map -*- C++ -*-
-
-// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/hashtable
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-// This header file defines std::tr1::hashtable, which is used to
-// implement std::tr1::unordered_set, std::tr1::unordered_map, 
-// std::tr1::unordered_multiset, and std::tr1::unordered_multimap.
-// hashtable has many template parameters, partly to accommodate
-// the differences between those four classes and partly to 
-// accommodate policy choices that go beyond TR1 specifications.
-
-// Class template hashtable attempts to encapsulate all reasonable
-// variation among hash tables that use chaining.  It does not handle
-// open addressing.
-
-// References: 
-// M. Austern, "A Proposal to Add Hash Tables to the Standard
-//    Library (revision 4)," WG21 Document N1456=03-0039, 2003.
-// D. E. Knuth, The Art of Computer Programming, v. 3, Sorting and Searching.
-// A. Tavori and V. Dreizin, "Policy-Based Data Structures", 2004.
-// http://gcc.gnu.org/onlinedocs/libstdc++/ext/pb_ds/index.html
-
-#include <tr1_impl/hashtable_policy.h>
-
-namespace std
-{ 
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-  // Class template _Hashtable, class definition.
-  
-  // Meaning of class template _Hashtable's template parameters
-  
-  // _Key and _Value: arbitrary CopyConstructible types.
-  
-  // _Allocator: an allocator type ([lib.allocator.requirements]) whose
-  // value type is Value.  As a conforming extension, we allow for
-  // value type != Value.
-
-  // _ExtractKey: function object that takes a object of type Value
-  // and returns a value of type _Key.
-  
-  // _Equal: function object that takes two objects of type k and returns
-  // a bool-like value that is true if the two objects are considered equal.
-  
-  // _H1: the hash function.  A unary function object with argument type
-  // Key and result type size_t.  Return values should be distributed
-  // over the entire range [0, numeric_limits<size_t>:::max()].
-  
-  // _H2: the range-hashing function (in the terminology of Tavori and
-  // Dreizin).  A binary function object whose argument types and result
-  // type are all size_t.  Given arguments r and N, the return value is
-  // in the range [0, N).
-  
-  // _Hash: the ranged hash function (Tavori and Dreizin). A binary function
-  // whose argument types are _Key and size_t and whose result type is
-  // size_t.  Given arguments k and N, the return value is in the range
-  // [0, N).  Default: hash(k, N) = h2(h1(k), N).  If _Hash is anything other
-  // than the default, _H1 and _H2 are ignored.
-  
-  // _RehashPolicy: Policy class with three members, all of which govern
-  // the bucket count. _M_next_bkt(n) returns a bucket count no smaller
-  // than n.  _M_bkt_for_elements(n) returns a bucket count appropriate
-  // for an element count of n.  _M_need_rehash(n_bkt, n_elt, n_ins)
-  // determines whether, if the current bucket count is n_bkt and the
-  // current element count is n_elt, we need to increase the bucket
-  // count.  If so, returns make_pair(true, n), where n is the new
-  // bucket count.  If not, returns make_pair(false, <anything>).
-  
-  // ??? Right now it is hard-wired that the number of buckets never
-  // shrinks.  Should we allow _RehashPolicy to change that?
-  
-  // __cache_hash_code: bool.  true if we store the value of the hash
-  // function along with the value.  This is a time-space tradeoff.
-  // Storing it may improve lookup speed by reducing the number of times
-  // we need to call the Equal function.
-  
-  // __constant_iterators: bool.  true if iterator and const_iterator are
-  // both constant iterator types.  This is true for unordered_set and
-  // unordered_multiset, false for unordered_map and unordered_multimap.
-  
-  // __unique_keys: bool.  true if the return value of _Hashtable::count(k)
-  // is always at most one, false if it may be an arbitrary number.  This
-  // true for unordered_set and unordered_map, false for unordered_multiset
-  // and unordered_multimap.
-  
-  template<typename _Key, typename _Value, typename _Allocator,
-	   typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, 
-	   typename _RehashPolicy,
-	   bool __cache_hash_code,
-	   bool __constant_iterators,
-	   bool __unique_keys>
-    class _Hashtable
-    : public __detail::_Rehash_base<_RehashPolicy,
-				    _Hashtable<_Key, _Value, _Allocator,
-					       _ExtractKey,
-					       _Equal, _H1, _H2, _Hash,
-					       _RehashPolicy,
-					       __cache_hash_code,
-					       __constant_iterators,
-					       __unique_keys> >,
-      public __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
-				       _H1, _H2, _Hash, __cache_hash_code>,
-      public __detail::_Map_base<_Key, _Value, _ExtractKey, __unique_keys,
-				 _Hashtable<_Key, _Value, _Allocator,
-					    _ExtractKey,
-					    _Equal, _H1, _H2, _Hash,
-					    _RehashPolicy,
-					    __cache_hash_code,
-					    __constant_iterators,
-					    __unique_keys> >
-    {
-    public:
-      typedef _Allocator                                  allocator_type;
-      typedef _Value                                      value_type;
-      typedef _Key                                        key_type;
-      typedef _Equal                                      key_equal;
-      // mapped_type, if present, comes from _Map_base.
-      // hasher, if present, comes from _Hash_code_base.
-      typedef typename _Allocator::difference_type        difference_type;
-      typedef typename _Allocator::size_type              size_type;
-      typedef typename _Allocator::pointer                pointer;
-      typedef typename _Allocator::const_pointer          const_pointer;
-      typedef typename _Allocator::reference              reference;
-      typedef typename _Allocator::const_reference        const_reference;
-      
-      typedef __detail::_Node_iterator<value_type, __constant_iterators,
-				       __cache_hash_code>
-                                                          local_iterator;
-      typedef __detail::_Node_const_iterator<value_type,
-					     __constant_iterators,
-					     __cache_hash_code>
-                                                          const_local_iterator;
-
-      typedef __detail::_Hashtable_iterator<value_type, __constant_iterators,
-					    __cache_hash_code>
-                                                          iterator;
-      typedef __detail::_Hashtable_const_iterator<value_type,
-						  __constant_iterators,
-						  __cache_hash_code>
-                                                          const_iterator;
-
-      template<typename _Key2, typename _Value2, typename _Ex2, bool __unique2,
-	       typename _Hashtable2>
-        friend struct __detail::_Map_base;
-
-    private:
-      typedef __detail::_Hash_node<_Value, __cache_hash_code> _Node;
-      typedef typename _Allocator::template rebind<_Node>::other
-                                                        _Node_allocator_type;
-      typedef typename _Allocator::template rebind<_Node*>::other
-                                                        _Bucket_allocator_type;
-
-      typedef typename _Allocator::template rebind<_Value>::other
-                                                        _Value_allocator_type;
-
-      _Node_allocator_type   _M_node_allocator;
-      _Node**                _M_buckets;
-      size_type              _M_bucket_count;
-      size_type              _M_element_count;
-      _RehashPolicy          _M_rehash_policy;
-      
-      _Node*
-      _M_allocate_node(const value_type& __v);
-  
-      void
-      _M_deallocate_node(_Node* __n);
-  
-      void
-      _M_deallocate_nodes(_Node**, size_type);
-
-      _Node**
-      _M_allocate_buckets(size_type __n);
-  
-      void
-      _M_deallocate_buckets(_Node**, size_type __n);
-
-    public:			    
-      // Constructor, destructor, assignment, swap
-      _Hashtable(size_type __bucket_hint,
-		 const _H1&, const _H2&, const _Hash&,
-		 const _Equal&, const _ExtractKey&,
-		 const allocator_type&);
-  
-      template<typename _InputIterator>
-        _Hashtable(_InputIterator __first, _InputIterator __last,
-		   size_type __bucket_hint,
-		   const _H1&, const _H2&, const _Hash&, 
-		   const _Equal&, const _ExtractKey&,
-		   const allocator_type&);
-  
-      _Hashtable(const _Hashtable&);
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      _Hashtable(_Hashtable&&);
-#endif
-      
-      _Hashtable&
-      operator=(const _Hashtable&);
-
-      ~_Hashtable();
-
-      void swap(_Hashtable&);
-
-      // Basic container operations
-      iterator
-      begin()
-      {
-	iterator __i(_M_buckets);
-	if (!__i._M_cur_node)
-	  __i._M_incr_bucket();
-	return __i;
-      }
-
-      const_iterator
-      begin() const
-      {
-	const_iterator __i(_M_buckets);
-	if (!__i._M_cur_node)
-	  __i._M_incr_bucket();
-	return __i;
-      }
-
-      iterator
-      end()
-      { return iterator(_M_buckets + _M_bucket_count); }
-
-      const_iterator
-      end() const
-      { return const_iterator(_M_buckets + _M_bucket_count); }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      const_iterator
-      cbegin() const
-      {
-	const_iterator __i(_M_buckets);
-	if (!__i._M_cur_node)
-	  __i._M_incr_bucket();
-	return __i;
-      }
-
-      const_iterator
-      cend() const
-      { return const_iterator(_M_buckets + _M_bucket_count); }
-#endif
-
-      size_type
-      size() const
-      { return _M_element_count; }
-  
-      bool
-      empty() const
-      { return size() == 0; }
-
-      allocator_type
-      get_allocator() const
-      { return allocator_type(_M_node_allocator); }
-
-      _Value_allocator_type
-      _M_get_Value_allocator() const
-      { return _Value_allocator_type(_M_node_allocator); }
-
-      size_type
-      max_size() const
-      { return _M_node_allocator.max_size(); }
-
-      // Observers
-      key_equal
-      key_eq() const
-      { return this->_M_eq; }
-
-      // hash_function, if present, comes from _Hash_code_base.
-
-      // Bucket operations
-      size_type
-      bucket_count() const
-      { return _M_bucket_count; }
-  
-      size_type
-      max_bucket_count() const
-      { return max_size(); }
-  
-      size_type
-      bucket_size(size_type __n) const
-      { return std::distance(begin(__n), end(__n)); }
-  
-      size_type
-      bucket(const key_type& __k) const
-      { 
-	return this->_M_bucket_index(__k, this->_M_hash_code(__k),
-				     bucket_count());
-      }
-
-      local_iterator
-      begin(size_type __n)
-      { return local_iterator(_M_buckets[__n]); }
-
-      local_iterator
-      end(size_type)
-      { return local_iterator(0); }
-
-      const_local_iterator
-      begin(size_type __n) const
-      { return const_local_iterator(_M_buckets[__n]); }
-
-      const_local_iterator
-      end(size_type) const
-      { return const_local_iterator(0); }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      // DR 691.
-      const_local_iterator
-      cbegin(size_type __n) const
-      { return const_local_iterator(_M_buckets[__n]); }
-
-      const_local_iterator
-      cend(size_type) const
-      { return const_local_iterator(0); }
-#endif
-
-      float
-      load_factor() const
-      { 
-	return static_cast<float>(size()) / static_cast<float>(bucket_count());
-      }
-
-      // max_load_factor, if present, comes from _Rehash_base.
-
-      // Generalization of max_load_factor.  Extension, not found in TR1.  Only
-      // useful if _RehashPolicy is something other than the default.
-      const _RehashPolicy&
-      __rehash_policy() const
-      { return _M_rehash_policy; }
-      
-      void 
-      __rehash_policy(const _RehashPolicy&);
-
-      // Lookup.
-      iterator
-      find(const key_type& __k);
-
-      const_iterator
-      find(const key_type& __k) const;
-
-      size_type
-      count(const key_type& __k) const;
-
-      std::pair<iterator, iterator>
-      equal_range(const key_type& __k);
-
-      std::pair<const_iterator, const_iterator>
-      equal_range(const key_type& __k) const;
-
-    private:			// Find, insert and erase helper functions
-      // ??? This dispatching is a workaround for the fact that we don't
-      // have partial specialization of member templates; it would be
-      // better to just specialize insert on __unique_keys.  There may be a
-      // cleaner workaround.
-      typedef typename __gnu_cxx::__conditional_type<__unique_keys,
-		       	    std::pair<iterator, bool>, iterator>::__type
-        _Insert_Return_Type;
-
-      typedef typename __gnu_cxx::__conditional_type<__unique_keys,
-					  std::_Select1st<_Insert_Return_Type>,
-				  	  std::_Identity<_Insert_Return_Type>
-                                   >::__type
-        _Insert_Conv_Type;
-
-      _Node*
-      _M_find_node(_Node*, const key_type&,
-		   typename _Hashtable::_Hash_code_type) const;
-
-      iterator
-      _M_insert_bucket(const value_type&, size_type,
-		       typename _Hashtable::_Hash_code_type);
-
-      std::pair<iterator, bool>
-      _M_insert(const value_type&, std::_GLIBCXX_TR1 true_type);
-
-      iterator
-      _M_insert(const value_type&, std::_GLIBCXX_TR1 false_type);
-
-      void
-      _M_erase_node(_Node*, _Node**);
-
-    public:				
-      // Insert and erase
-      _Insert_Return_Type
-      insert(const value_type& __v) 
-      { return _M_insert(__v, std::_GLIBCXX_TR1 integral_constant<bool,
-			 __unique_keys>()); }
-
-      iterator
-      insert(iterator, const value_type& __v)
-      { return iterator(_Insert_Conv_Type()(this->insert(__v))); }
-
-      const_iterator
-      insert(const_iterator, const value_type& __v)
-      { return const_iterator(_Insert_Conv_Type()(this->insert(__v))); }
-
-      template<typename _InputIterator>
-        void
-        insert(_InputIterator __first, _InputIterator __last);
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      void
-      insert(initializer_list<value_type> __l)
-      { this->insert(__l.begin(), __l.end()); }
-#endif
-
-      iterator
-      erase(iterator);
-
-      const_iterator
-      erase(const_iterator);
-
-      size_type
-      erase(const key_type&);
-
-      iterator
-      erase(iterator, iterator);
-
-      const_iterator
-      erase(const_iterator, const_iterator);
-
-      void
-      clear();
-
-      // Set number of buckets to be appropriate for container of n element.
-      void rehash(size_type __n);
-      
-    private:
-      // Unconditionally change size of bucket array to n.
-      void _M_rehash(size_type __n);
-    };
-
-
-  // Definitions of class template _Hashtable's out-of-line member functions.
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-			_H1, _H2, _Hash, _RehashPolicy,
-			__chc, __cit, __uk>::_Node*
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    _M_allocate_node(const value_type& __v)
-    {
-      _Node* __n = _M_node_allocator.allocate(1);
-      __try
-	{
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-	  _M_node_allocator.construct(__n, __v);
-#else
-	  _M_get_Value_allocator().construct(&__n->_M_v, __v);
-#endif
-	  __n->_M_next = 0;
-	  return __n;
-	}
-      __catch(...)
-	{
-	  _M_node_allocator.deallocate(__n, 1);
-	  __throw_exception_again;
-	}
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    void
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    _M_deallocate_node(_Node* __n)
-    {
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      _M_node_allocator.destroy(__n);
-#else
-      _M_get_Value_allocator().destroy(&__n->_M_v);
-#endif
-      _M_node_allocator.deallocate(__n, 1);
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    void
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    _M_deallocate_nodes(_Node** __array, size_type __n)
-    {
-      for (size_type __i = 0; __i < __n; ++__i)
-	{
-	  _Node* __p = __array[__i];
-	  while (__p)
-	    {
-	      _Node* __tmp = __p;
-	      __p = __p->_M_next;
-	      _M_deallocate_node(__tmp);
-	    }
-	  __array[__i] = 0;
-	}
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-			_H1, _H2, _Hash, _RehashPolicy,
-			__chc, __cit, __uk>::_Node**
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    _M_allocate_buckets(size_type __n)
-    {
-      _Bucket_allocator_type __alloc(_M_node_allocator);
-
-      // We allocate one extra bucket to hold a sentinel, an arbitrary
-      // non-null pointer.  Iterator increment relies on this.
-      _Node** __p = __alloc.allocate(__n + 1);
-      std::fill(__p, __p + __n, (_Node*) 0);
-      __p[__n] = reinterpret_cast<_Node*>(0x1000);
-      return __p;
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    void
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    _M_deallocate_buckets(_Node** __p, size_type __n)
-    {
-      _Bucket_allocator_type __alloc(_M_node_allocator);
-      __alloc.deallocate(__p, __n + 1);
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    _Hashtable(size_type __bucket_hint,
-	       const _H1& __h1, const _H2& __h2, const _Hash& __h,
-	       const _Equal& __eq, const _ExtractKey& __exk,
-	       const allocator_type& __a)
-    : __detail::_Rehash_base<_RehashPolicy, _Hashtable>(),
-      __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
-				_H1, _H2, _Hash, __chc>(__exk, __eq,
-							__h1, __h2, __h),
-      __detail::_Map_base<_Key, _Value, _ExtractKey, __uk, _Hashtable>(),
-      _M_node_allocator(__a),
-      _M_bucket_count(0),
-      _M_element_count(0),
-      _M_rehash_policy()
-    {
-      _M_bucket_count = _M_rehash_policy._M_next_bkt(__bucket_hint);
-      _M_buckets = _M_allocate_buckets(_M_bucket_count);
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    template<typename _InputIterator>
-      _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-		 _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-      _Hashtable(_InputIterator __f, _InputIterator __l,
-		 size_type __bucket_hint,
-		 const _H1& __h1, const _H2& __h2, const _Hash& __h,
-		 const _Equal& __eq, const _ExtractKey& __exk,
-		 const allocator_type& __a)
-      : __detail::_Rehash_base<_RehashPolicy, _Hashtable>(),
-	__detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
-				  _H1, _H2, _Hash, __chc>(__exk, __eq,
-							  __h1, __h2, __h),
-	__detail::_Map_base<_Key, _Value, _ExtractKey, __uk, _Hashtable>(),
-	_M_node_allocator(__a),
-	_M_bucket_count(0),
-	_M_element_count(0),
-	_M_rehash_policy()
-      {
-	_M_bucket_count = std::max(_M_rehash_policy._M_next_bkt(__bucket_hint),
-				   _M_rehash_policy.
-				   _M_bkt_for_elements(__detail::
-						       __distance_fw(__f,
-								     __l)));
-	_M_buckets = _M_allocate_buckets(_M_bucket_count);
-	__try
-	  {
-	    for (; __f != __l; ++__f)
-	      this->insert(*__f);
-	  }
-	__catch(...)
-	  {
-	    clear();
-	    _M_deallocate_buckets(_M_buckets, _M_bucket_count);
-	    __throw_exception_again;
-	  }
-      }
-  
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    _Hashtable(const _Hashtable& __ht)
-    : __detail::_Rehash_base<_RehashPolicy, _Hashtable>(__ht),
-      __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
-				_H1, _H2, _Hash, __chc>(__ht),
-      __detail::_Map_base<_Key, _Value, _ExtractKey, __uk, _Hashtable>(__ht),
-      _M_node_allocator(__ht._M_node_allocator),
-      _M_bucket_count(__ht._M_bucket_count),
-      _M_element_count(__ht._M_element_count),
-      _M_rehash_policy(__ht._M_rehash_policy)
-    {
-      _M_buckets = _M_allocate_buckets(_M_bucket_count);
-      __try
-	{
-	  for (size_type __i = 0; __i < __ht._M_bucket_count; ++__i)
-	    {
-	      _Node* __n = __ht._M_buckets[__i];
-	      _Node** __tail = _M_buckets + __i;
-	      while (__n)
-		{
-		  *__tail = _M_allocate_node(__n->_M_v);
-		  this->_M_copy_code(*__tail, __n);
-		  __tail = &((*__tail)->_M_next);
-		  __n = __n->_M_next;
-		}
-	    }
-	}
-      __catch(...)
-	{
-	  clear();
-	  _M_deallocate_buckets(_M_buckets, _M_bucket_count);
-	  __throw_exception_again;
-	}
-    }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    _Hashtable(_Hashtable&& __ht)
-    : __detail::_Rehash_base<_RehashPolicy, _Hashtable>(__ht),
-      __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
-				_H1, _H2, _Hash, __chc>(__ht),
-      __detail::_Map_base<_Key, _Value, _ExtractKey, __uk, _Hashtable>(__ht),
-      _M_node_allocator(__ht._M_node_allocator),
-      _M_bucket_count(__ht._M_bucket_count),
-      _M_element_count(__ht._M_element_count),
-      _M_rehash_policy(__ht._M_rehash_policy),
-      _M_buckets(__ht._M_buckets)
-    {
-      size_type __n_bkt = __ht._M_rehash_policy._M_next_bkt(0);
-      __ht._M_buckets = __ht._M_allocate_buckets(__n_bkt);
-      __ht._M_bucket_count = __n_bkt;
-      __ht._M_element_count = 0;
-      __ht._M_rehash_policy = _RehashPolicy();
-    }
-#endif
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>&
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    operator=(const _Hashtable& __ht)
-    {
-      _Hashtable __tmp(__ht);
-      this->swap(__tmp);
-      return *this;
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    ~_Hashtable()
-    {
-      clear();
-      _M_deallocate_buckets(_M_buckets, _M_bucket_count);
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    void
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    swap(_Hashtable& __x)
-    {
-      // The only base class with member variables is hash_code_base.  We
-      // define _Hash_code_base::_M_swap because different specializations
-      // have different members.
-      __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
-	_H1, _H2, _Hash, __chc>::_M_swap(__x);
-
-      // _GLIBCXX_RESOLVE_LIB_DEFECTS
-      // 431. Swapping containers with unequal allocators.
-      std::__alloc_swap<_Node_allocator_type>::_S_do_it(_M_node_allocator,
-							__x._M_node_allocator);
-
-      std::swap(_M_rehash_policy, __x._M_rehash_policy);
-      std::swap(_M_buckets, __x._M_buckets);
-      std::swap(_M_bucket_count, __x._M_bucket_count);
-      std::swap(_M_element_count, __x._M_element_count);
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    void
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    __rehash_policy(const _RehashPolicy& __pol)
-    {
-      _M_rehash_policy = __pol;
-      size_type __n_bkt = __pol._M_bkt_for_elements(_M_element_count);
-      if (__n_bkt > _M_bucket_count)
-	_M_rehash(__n_bkt);
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-			_H1, _H2, _Hash, _RehashPolicy,
-			__chc, __cit, __uk>::iterator
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    find(const key_type& __k)
-    {
-      typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
-      std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
-      _Node* __p = _M_find_node(_M_buckets[__n], __k, __code);
-      return __p ? iterator(__p, _M_buckets + __n) : this->end();
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-			_H1, _H2, _Hash, _RehashPolicy,
-			__chc, __cit, __uk>::const_iterator
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    find(const key_type& __k) const
-    {
-      typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
-      std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
-      _Node* __p = _M_find_node(_M_buckets[__n], __k, __code);
-      return __p ? const_iterator(__p, _M_buckets + __n) : this->end();
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-			_H1, _H2, _Hash, _RehashPolicy,
-			__chc, __cit, __uk>::size_type
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    count(const key_type& __k) const
-    {
-      typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
-      std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
-      std::size_t __result = 0;
-      for (_Node* __p = _M_buckets[__n]; __p; __p = __p->_M_next)
-	if (this->_M_compare(__k, __code, __p))
-	  ++__result;
-      return __result;
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    std::pair<typename _Hashtable<_Key, _Value, _Allocator,
-				  _ExtractKey, _Equal, _H1,
-				  _H2, _Hash, _RehashPolicy,
-				  __chc, __cit, __uk>::iterator,
-	      typename _Hashtable<_Key, _Value, _Allocator,
-				  _ExtractKey, _Equal, _H1,
-				  _H2, _Hash, _RehashPolicy,
-				  __chc, __cit, __uk>::iterator>
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    equal_range(const key_type& __k)
-    {
-      typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
-      std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
-      _Node** __head = _M_buckets + __n;
-      _Node* __p = _M_find_node(*__head, __k, __code);
-      
-      if (__p)
-	{
-	  _Node* __p1 = __p->_M_next;
-	  for (; __p1; __p1 = __p1->_M_next)
-	    if (!this->_M_compare(__k, __code, __p1))
-	      break;
-
-	  iterator __first(__p, __head);
-	  iterator __last(__p1, __head);
-	  if (!__p1)
-	    __last._M_incr_bucket();
-	  return std::make_pair(__first, __last);
-	}
-      else
-	return std::make_pair(this->end(), this->end());
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    std::pair<typename _Hashtable<_Key, _Value, _Allocator,
-				  _ExtractKey, _Equal, _H1,
-				  _H2, _Hash, _RehashPolicy,
-				  __chc, __cit, __uk>::const_iterator,
-	      typename _Hashtable<_Key, _Value, _Allocator,
-				  _ExtractKey, _Equal, _H1,
-				  _H2, _Hash, _RehashPolicy,
-				  __chc, __cit, __uk>::const_iterator>
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    equal_range(const key_type& __k) const
-    {
-      typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
-      std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
-      _Node** __head = _M_buckets + __n;
-      _Node* __p = _M_find_node(*__head, __k, __code);
-
-      if (__p)
-	{
-	  _Node* __p1 = __p->_M_next;
-	  for (; __p1; __p1 = __p1->_M_next)
-	    if (!this->_M_compare(__k, __code, __p1))
-	      break;
-
-	  const_iterator __first(__p, __head);
-	  const_iterator __last(__p1, __head);
-	  if (!__p1)
-	    __last._M_incr_bucket();
-	  return std::make_pair(__first, __last);
-	}
-      else
-	return std::make_pair(this->end(), this->end());
-    }
-
-  // Find the node whose key compares equal to k, beginning the search
-  // at p (usually the head of a bucket).  Return nil if no node is found.
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey,
-			_Equal, _H1, _H2, _Hash, _RehashPolicy,
-			__chc, __cit, __uk>::_Node* 
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    _M_find_node(_Node* __p, const key_type& __k,
-		typename _Hashtable::_Hash_code_type __code) const
-    {
-      for (; __p; __p = __p->_M_next)
-	if (this->_M_compare(__k, __code, __p))
-	  return __p;
-      return false;
-    }
-
-  // Insert v in bucket n (assumes no element with its key already present).
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-			_H1, _H2, _Hash, _RehashPolicy,
-			__chc, __cit, __uk>::iterator
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    _M_insert_bucket(const value_type& __v, size_type __n,
-		    typename _Hashtable::_Hash_code_type __code)
-    {
-      std::pair<bool, std::size_t> __do_rehash
-	= _M_rehash_policy._M_need_rehash(_M_bucket_count,
-					  _M_element_count, 1);
-
-      // Allocate the new node before doing the rehash so that we don't
-      // do a rehash if the allocation throws.
-      _Node* __new_node = _M_allocate_node(__v);
-
-      __try
-	{
-	  if (__do_rehash.first)
-	    {
-	      const key_type& __k = this->_M_extract(__v);
-	      __n = this->_M_bucket_index(__k, __code, __do_rehash.second);
-	      _M_rehash(__do_rehash.second);
-	    }
-
-	  __new_node->_M_next = _M_buckets[__n];
-	  this->_M_store_code(__new_node, __code);
-	  _M_buckets[__n] = __new_node;
-	  ++_M_element_count;
-	  return iterator(__new_node, _M_buckets + __n);
-	}
-      __catch(...)
-	{
-	  _M_deallocate_node(__new_node);
-	  __throw_exception_again;
-	}
-    }
-
-  // Insert v if no element with its key is already present.
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    std::pair<typename _Hashtable<_Key, _Value, _Allocator,
-				  _ExtractKey, _Equal, _H1,
-				  _H2, _Hash, _RehashPolicy,
-				  __chc, __cit, __uk>::iterator, bool>
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    _M_insert(const value_type& __v, std::_GLIBCXX_TR1 true_type)
-    {
-      const key_type& __k = this->_M_extract(__v);
-      typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
-      size_type __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
-
-      if (_Node* __p = _M_find_node(_M_buckets[__n], __k, __code))
-	return std::make_pair(iterator(__p, _M_buckets + __n), false);
-      return std::make_pair(_M_insert_bucket(__v, __n, __code), true);
-    }
-  
-  // Insert v unconditionally.
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-			_H1, _H2, _Hash, _RehashPolicy,
-			__chc, __cit, __uk>::iterator
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    _M_insert(const value_type& __v, std::_GLIBCXX_TR1 false_type)
-    {
-      std::pair<bool, std::size_t> __do_rehash
-	= _M_rehash_policy._M_need_rehash(_M_bucket_count,
-					  _M_element_count, 1);
-      if (__do_rehash.first)
-	_M_rehash(__do_rehash.second);
- 
-      const key_type& __k = this->_M_extract(__v);
-      typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
-      size_type __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
-
-      // First find the node, avoid leaking new_node if compare throws.
-      _Node* __prev = _M_find_node(_M_buckets[__n], __k, __code);
-      _Node* __new_node = _M_allocate_node(__v);
-
-      if (__prev)
-	{
-	  __new_node->_M_next = __prev->_M_next;
-	  __prev->_M_next = __new_node;
-	}
-      else
-	{
-	  __new_node->_M_next = _M_buckets[__n];
-	  _M_buckets[__n] = __new_node;
-	}
-      this->_M_store_code(__new_node, __code);
-
-      ++_M_element_count;
-      return iterator(__new_node, _M_buckets + __n);
-    }
-
-  // For erase(iterator) and erase(const_iterator).
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    void
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    _M_erase_node(_Node* __p, _Node** __b)
-    {
-      _Node* __cur = *__b;
-      if (__cur == __p)
-	*__b = __cur->_M_next;
-      else
-	{
-	  _Node* __next = __cur->_M_next;
-	  while (__next != __p)
-	    {
-	      __cur = __next;
-	      __next = __cur->_M_next;
-	    }
-	  __cur->_M_next = __next->_M_next;
-	}
-
-      _M_deallocate_node(__p);
-      --_M_element_count;
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    template<typename _InputIterator>
-      void 
-      _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-		 _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-      insert(_InputIterator __first, _InputIterator __last)
-      {
-	size_type __n_elt = __detail::__distance_fw(__first, __last);
-	std::pair<bool, std::size_t> __do_rehash
-	  = _M_rehash_policy._M_need_rehash(_M_bucket_count,
-					    _M_element_count, __n_elt);
-	if (__do_rehash.first)
-	  _M_rehash(__do_rehash.second);
-
-	for (; __first != __last; ++__first)
-	  this->insert(*__first);
-      }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-			_H1, _H2, _Hash, _RehashPolicy,
-			__chc, __cit, __uk>::iterator
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    erase(iterator __it)
-    {
-      iterator __result = __it;
-      ++__result;
-      _M_erase_node(__it._M_cur_node, __it._M_cur_bucket);
-      return __result;
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-			_H1, _H2, _Hash, _RehashPolicy,
-			__chc, __cit, __uk>::const_iterator
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    erase(const_iterator __it)
-    {
-      const_iterator __result = __it;
-      ++__result;
-      _M_erase_node(__it._M_cur_node, __it._M_cur_bucket);
-      return __result;
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-			_H1, _H2, _Hash, _RehashPolicy,
-			__chc, __cit, __uk>::size_type
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    erase(const key_type& __k)
-    {
-      typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
-      std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
-      size_type __result = 0;
-      
-      _Node** __slot = _M_buckets + __n;
-      while (*__slot && !this->_M_compare(__k, __code, *__slot))
-	__slot = &((*__slot)->_M_next);
-
-      _Node** __saved_slot = 0;
-      while (*__slot && this->_M_compare(__k, __code, *__slot))
-	{
-	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
-	  // 526. Is it undefined if a function in the standard changes
-	  // in parameters?
-	  if (&this->_M_extract((*__slot)->_M_v) != &__k)
-	    {
-              _Node* __p = *__slot;
-              *__slot = __p->_M_next;
-	      _M_deallocate_node(__p);
-	      --_M_element_count;
-	      ++__result;
-	    }
-	  else
-	    {
-	      __saved_slot = __slot;
-	      __slot = &((*__slot)->_M_next);
-	    }
-	}
-
-      if (__saved_slot)
-	{
-	  _Node* __p = *__saved_slot;
-	  *__saved_slot = __p->_M_next;
-	  _M_deallocate_node(__p);
-	  --_M_element_count;
-	  ++__result;
-	}
-
-      return __result;
-    }
-
-  // ??? This could be optimized by taking advantage of the bucket
-  // structure, but it's not clear that it's worth doing.  It probably
-  // wouldn't even be an optimization unless the load factor is large.
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-			_H1, _H2, _Hash, _RehashPolicy,
-			__chc, __cit, __uk>::iterator
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    erase(iterator __first, iterator __last)
-    {
-      while (__first != __last)
-	__first = this->erase(__first);
-      return __last;
-    }
-  
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-			_H1, _H2, _Hash, _RehashPolicy,
-			__chc, __cit, __uk>::const_iterator
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    erase(const_iterator __first, const_iterator __last)
-    {
-      while (__first != __last)
-	__first = this->erase(__first);
-      return __last;
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    void
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    clear()
-    {
-      _M_deallocate_nodes(_M_buckets, _M_bucket_count);
-      _M_element_count = 0;
-    }
- 
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    void
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    rehash(size_type __n)
-    {
-      _M_rehash(std::max(_M_rehash_policy._M_next_bkt(__n),
-			 _M_rehash_policy._M_bkt_for_elements(_M_element_count
-							      + 1)));
-    }
-
-  template<typename _Key, typename _Value, 
-	   typename _Allocator, typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-	   bool __chc, bool __cit, bool __uk>
-    void
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    _M_rehash(size_type __n)
-    {
-      _Node** __new_array = _M_allocate_buckets(__n);
-      __try
-	{
-	  for (size_type __i = 0; __i < _M_bucket_count; ++__i)
-	    while (_Node* __p = _M_buckets[__i])
-	      {
-		std::size_t __new_index = this->_M_bucket_index(__p, __n);
-		_M_buckets[__i] = __p->_M_next;
-		__p->_M_next = __new_array[__new_index];
-		__new_array[__new_index] = __p;
-	      }
-	  _M_deallocate_buckets(_M_buckets, _M_bucket_count);
-	  _M_bucket_count = __n;
-	  _M_buckets = __new_array;
-	}
-      __catch(...)
-	{
-	  // A failure here means that a hash function threw an exception.
-	  // We can't restore the previous state without calling the hash
-	  // function again, so the only sensible recovery is to delete
-	  // everything.
-	  _M_deallocate_nodes(__new_array, __n);
-	  _M_deallocate_buckets(__new_array, __n);
-	  _M_deallocate_nodes(_M_buckets, _M_bucket_count);
-	  _M_element_count = 0;
-	  __throw_exception_again;
-	}
-    }
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/hashtable_policy.h b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/hashtable_policy.h
deleted file mode 100644
index 8996d04d9..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/hashtable_policy.h
+++ /dev/null
@@ -1,865 +0,0 @@
-// Internal policy header for TR1 unordered_set and unordered_map -*- C++ -*-
-
-// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/hashtable_policy.h
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-namespace std
-{ 
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-namespace __detail
-{
-  // Helper function: return distance(first, last) for forward
-  // iterators, or 0 for input iterators.
-  template<class _Iterator>
-    inline typename std::iterator_traits<_Iterator>::difference_type
-    __distance_fw(_Iterator __first, _Iterator __last,
-		  std::input_iterator_tag)
-    { return 0; }
-
-  template<class _Iterator>
-    inline typename std::iterator_traits<_Iterator>::difference_type
-    __distance_fw(_Iterator __first, _Iterator __last,
-		  std::forward_iterator_tag)
-    { return std::distance(__first, __last); }
-
-  template<class _Iterator>
-    inline typename std::iterator_traits<_Iterator>::difference_type
-    __distance_fw(_Iterator __first, _Iterator __last)
-    {
-      typedef typename std::iterator_traits<_Iterator>::iterator_category _Tag;
-      return __distance_fw(__first, __last, _Tag());
-    }
-
-  template<typename _RAIter, typename _Tp>
-    _RAIter
-    __lower_bound(_RAIter __first, _RAIter __last, const _Tp& __val)
-    {
-      typedef typename std::iterator_traits<_RAIter>::difference_type _DType;
-
-      _DType __len = __last - __first;
-      while (__len > 0)
-	{
-	  _DType __half = __len >> 1;
-	  _RAIter __middle = __first + __half;
-	  if (*__middle < __val)
-	    {
-	      __first = __middle;
-	      ++__first;
-	      __len = __len - __half - 1;
-	    }
-	  else
-	    __len = __half;
-	}
-      return __first;
-    }
-
-  // Auxiliary types used for all instantiations of _Hashtable: nodes
-  // and iterators.
-  
-  // Nodes, used to wrap elements stored in the hash table.  A policy
-  // template parameter of class template _Hashtable controls whether
-  // nodes also store a hash code. In some cases (e.g. strings) this
-  // may be a performance win.
-  template<typename _Value, bool __cache_hash_code>
-    struct _Hash_node;
-
-  template<typename _Value>
-    struct _Hash_node<_Value, true>
-    {
-      _Value       _M_v;
-      std::size_t  _M_hash_code;
-      _Hash_node*  _M_next;
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      template<typename... _Args>
-        _Hash_node(_Args&&... __args)
-	  : _M_v(std::forward<_Args>(__args)...),
-	    _M_hash_code(), _M_next() { }
-#endif
-    };
-
-  template<typename _Value>
-    struct _Hash_node<_Value, false>
-    {
-      _Value       _M_v;
-      _Hash_node*  _M_next;
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      template<typename... _Args>
-        _Hash_node(_Args&&... __args)
-	  : _M_v(std::forward<_Args>(__args)...),
-	    _M_next() { }
-#endif
-    };
-
-  // Local iterators, used to iterate within a bucket but not between
-  // buckets.
-  template<typename _Value, bool __cache>
-    struct _Node_iterator_base
-    {
-      _Node_iterator_base(_Hash_node<_Value, __cache>* __p)
-      : _M_cur(__p) { }
-      
-      void
-      _M_incr()
-      { _M_cur = _M_cur->_M_next; }
-
-      _Hash_node<_Value, __cache>*  _M_cur;
-    };
-
-  template<typename _Value, bool __cache>
-    inline bool
-    operator==(const _Node_iterator_base<_Value, __cache>& __x,
-	       const _Node_iterator_base<_Value, __cache>& __y)
-    { return __x._M_cur == __y._M_cur; }
-
-  template<typename _Value, bool __cache>
-    inline bool
-    operator!=(const _Node_iterator_base<_Value, __cache>& __x,
-	       const _Node_iterator_base<_Value, __cache>& __y)
-    { return __x._M_cur != __y._M_cur; }
-
-  template<typename _Value, bool __constant_iterators, bool __cache>
-    struct _Node_iterator
-    : public _Node_iterator_base<_Value, __cache>
-    {
-      typedef _Value                                   value_type;
-      typedef typename
-      __gnu_cxx::__conditional_type<__constant_iterators,
-				    const _Value*, _Value*>::__type
-                                                       pointer;
-      typedef typename
-      __gnu_cxx::__conditional_type<__constant_iterators,
-				    const _Value&, _Value&>::__type
-                                                       reference;
-      typedef std::ptrdiff_t                           difference_type;
-      typedef std::forward_iterator_tag                iterator_category;
-
-      _Node_iterator()
-      : _Node_iterator_base<_Value, __cache>(0) { }
-
-      explicit
-      _Node_iterator(_Hash_node<_Value, __cache>* __p)
-      : _Node_iterator_base<_Value, __cache>(__p) { }
-
-      reference
-      operator*() const
-      { return this->_M_cur->_M_v; }
-  
-      pointer
-      operator->() const
-      { return &this->_M_cur->_M_v; }
-
-      _Node_iterator&
-      operator++()
-      { 
-	this->_M_incr();
-	return *this; 
-      }
-  
-      _Node_iterator
-      operator++(int)
-      { 
-	_Node_iterator __tmp(*this);
-	this->_M_incr();
-	return __tmp;
-      }
-    };
-
-  template<typename _Value, bool __constant_iterators, bool __cache>
-    struct _Node_const_iterator
-    : public _Node_iterator_base<_Value, __cache>
-    {
-      typedef _Value                                   value_type;
-      typedef const _Value*                            pointer;
-      typedef const _Value&                            reference;
-      typedef std::ptrdiff_t                           difference_type;
-      typedef std::forward_iterator_tag                iterator_category;
-
-      _Node_const_iterator()
-      : _Node_iterator_base<_Value, __cache>(0) { }
-
-      explicit
-      _Node_const_iterator(_Hash_node<_Value, __cache>* __p)
-      : _Node_iterator_base<_Value, __cache>(__p) { }
-
-      _Node_const_iterator(const _Node_iterator<_Value, __constant_iterators,
-			   __cache>& __x)
-      : _Node_iterator_base<_Value, __cache>(__x._M_cur) { }
-
-      reference
-      operator*() const
-      { return this->_M_cur->_M_v; }
-  
-      pointer
-      operator->() const
-      { return &this->_M_cur->_M_v; }
-
-      _Node_const_iterator&
-      operator++()
-      { 
-	this->_M_incr();
-	return *this; 
-      }
-  
-      _Node_const_iterator
-      operator++(int)
-      { 
-	_Node_const_iterator __tmp(*this);
-	this->_M_incr();
-	return __tmp;
-      }
-    };
-
-  template<typename _Value, bool __cache>
-    struct _Hashtable_iterator_base
-    {
-      _Hashtable_iterator_base(_Hash_node<_Value, __cache>* __node,
-			       _Hash_node<_Value, __cache>** __bucket)
-      : _M_cur_node(__node), _M_cur_bucket(__bucket) { }
-
-      void
-      _M_incr()
-      {
-	_M_cur_node = _M_cur_node->_M_next;
-	if (!_M_cur_node)
-	  _M_incr_bucket();
-      }
-
-      void
-      _M_incr_bucket();
-
-      _Hash_node<_Value, __cache>*   _M_cur_node;
-      _Hash_node<_Value, __cache>**  _M_cur_bucket;
-    };
-
-  // Global iterators, used for arbitrary iteration within a hash
-  // table.  Larger and more expensive than local iterators.
-  template<typename _Value, bool __cache>
-    void
-    _Hashtable_iterator_base<_Value, __cache>::
-    _M_incr_bucket()
-    {
-      ++_M_cur_bucket;
-
-      // This loop requires the bucket array to have a non-null sentinel.
-      while (!*_M_cur_bucket)
-	++_M_cur_bucket;
-      _M_cur_node = *_M_cur_bucket;
-    }
-
-  template<typename _Value, bool __cache>
-    inline bool
-    operator==(const _Hashtable_iterator_base<_Value, __cache>& __x,
-	       const _Hashtable_iterator_base<_Value, __cache>& __y)
-    { return __x._M_cur_node == __y._M_cur_node; }
-
-  template<typename _Value, bool __cache>
-    inline bool
-    operator!=(const _Hashtable_iterator_base<_Value, __cache>& __x,
-	       const _Hashtable_iterator_base<_Value, __cache>& __y)
-    { return __x._M_cur_node != __y._M_cur_node; }
-
-  template<typename _Value, bool __constant_iterators, bool __cache>
-    struct _Hashtable_iterator
-    : public _Hashtable_iterator_base<_Value, __cache>
-    {
-      typedef _Value                                   value_type;
-      typedef typename
-      __gnu_cxx::__conditional_type<__constant_iterators,
-				    const _Value*, _Value*>::__type
-                                                       pointer;
-      typedef typename
-      __gnu_cxx::__conditional_type<__constant_iterators,
-				    const _Value&, _Value&>::__type
-                                                       reference;
-      typedef std::ptrdiff_t                           difference_type;
-      typedef std::forward_iterator_tag                iterator_category;
-
-      _Hashtable_iterator()
-      : _Hashtable_iterator_base<_Value, __cache>(0, 0) { }
-
-      _Hashtable_iterator(_Hash_node<_Value, __cache>* __p,
-			  _Hash_node<_Value, __cache>** __b)
-      : _Hashtable_iterator_base<_Value, __cache>(__p, __b) { }
-
-      explicit
-      _Hashtable_iterator(_Hash_node<_Value, __cache>** __b)
-      : _Hashtable_iterator_base<_Value, __cache>(*__b, __b) { }
-
-      reference
-      operator*() const
-      { return this->_M_cur_node->_M_v; }
-  
-      pointer
-      operator->() const
-      { return &this->_M_cur_node->_M_v; }
-
-      _Hashtable_iterator&
-      operator++()
-      { 
-	this->_M_incr();
-	return *this;
-      }
-  
-      _Hashtable_iterator
-      operator++(int)
-      { 
-	_Hashtable_iterator __tmp(*this);
-	this->_M_incr();
-	return __tmp;
-      }
-    };
-
-  template<typename _Value, bool __constant_iterators, bool __cache>
-    struct _Hashtable_const_iterator
-    : public _Hashtable_iterator_base<_Value, __cache>
-    {
-      typedef _Value                                   value_type;
-      typedef const _Value*                            pointer;
-      typedef const _Value&                            reference;
-      typedef std::ptrdiff_t                           difference_type;
-      typedef std::forward_iterator_tag                iterator_category;
-
-      _Hashtable_const_iterator()
-      : _Hashtable_iterator_base<_Value, __cache>(0, 0) { }
-
-      _Hashtable_const_iterator(_Hash_node<_Value, __cache>* __p,
-				_Hash_node<_Value, __cache>** __b)
-      : _Hashtable_iterator_base<_Value, __cache>(__p, __b) { }
-
-      explicit
-      _Hashtable_const_iterator(_Hash_node<_Value, __cache>** __b)
-      : _Hashtable_iterator_base<_Value, __cache>(*__b, __b) { }
-
-      _Hashtable_const_iterator(const _Hashtable_iterator<_Value,
-				__constant_iterators, __cache>& __x)
-      : _Hashtable_iterator_base<_Value, __cache>(__x._M_cur_node,
-						  __x._M_cur_bucket) { }
-
-      reference
-      operator*() const
-      { return this->_M_cur_node->_M_v; }
-  
-      pointer
-      operator->() const
-      { return &this->_M_cur_node->_M_v; }
-
-      _Hashtable_const_iterator&
-      operator++()
-      { 
-	this->_M_incr();
-	return *this;
-      }
-  
-      _Hashtable_const_iterator
-      operator++(int)
-      { 
-	_Hashtable_const_iterator __tmp(*this);
-	this->_M_incr();
-	return __tmp;
-      }
-    };
-
-
-  // Many of class template _Hashtable's template parameters are policy
-  // classes.  These are defaults for the policies.
-
-  // Default range hashing function: use division to fold a large number
-  // into the range [0, N).
-  struct _Mod_range_hashing
-  {
-    typedef std::size_t first_argument_type;
-    typedef std::size_t second_argument_type;
-    typedef std::size_t result_type;
-
-    result_type
-    operator()(first_argument_type __num, second_argument_type __den) const
-    { return __num % __den; }
-  };
-
-  // Default ranged hash function H.  In principle it should be a
-  // function object composed from objects of type H1 and H2 such that
-  // h(k, N) = h2(h1(k), N), but that would mean making extra copies of
-  // h1 and h2.  So instead we'll just use a tag to tell class template
-  // hashtable to do that composition.
-  struct _Default_ranged_hash { };
-
-  // Default value for rehash policy.  Bucket size is (usually) the
-  // smallest prime that keeps the load factor small enough.
-  struct _Prime_rehash_policy
-  {
-    _Prime_rehash_policy(float __z = 1.0)
-    : _M_max_load_factor(__z), _M_growth_factor(2.f), _M_next_resize(0) { }
-
-    float
-    max_load_factor() const
-    { return _M_max_load_factor; }      
-
-    // Return a bucket size no smaller than n.
-    std::size_t
-    _M_next_bkt(std::size_t __n) const;
-    
-    // Return a bucket count appropriate for n elements
-    std::size_t
-    _M_bkt_for_elements(std::size_t __n) const;
-    
-    // __n_bkt is current bucket count, __n_elt is current element count,
-    // and __n_ins is number of elements to be inserted.  Do we need to
-    // increase bucket count?  If so, return make_pair(true, n), where n
-    // is the new bucket count.  If not, return make_pair(false, 0).
-    std::pair<bool, std::size_t>
-    _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
-		   std::size_t __n_ins) const;
-
-    enum { _S_n_primes = sizeof(unsigned long) != 8 ? 256 : 256 + 48 };
-
-    float                _M_max_load_factor;
-    float                _M_growth_factor;
-    mutable std::size_t  _M_next_resize;
-  };
-
-  extern const unsigned long __prime_list[];
-
-  // XXX This is a hack.  There's no good reason for any of
-  // _Prime_rehash_policy's member functions to be inline.  
-
-  // Return a prime no smaller than n.
-  inline std::size_t
-  _Prime_rehash_policy::
-  _M_next_bkt(std::size_t __n) const
-  {
-    const unsigned long* __p = __lower_bound(__prime_list, __prime_list
-					     + _S_n_primes, __n);
-    _M_next_resize = 
-      static_cast<std::size_t>(__builtin_ceil(*__p * _M_max_load_factor));
-    return *__p;
-  }
-
-  // Return the smallest prime p such that alpha p >= n, where alpha
-  // is the load factor.
-  inline std::size_t
-  _Prime_rehash_policy::
-  _M_bkt_for_elements(std::size_t __n) const
-  {
-    const float __min_bkts = __n / _M_max_load_factor;
-    const unsigned long* __p = __lower_bound(__prime_list, __prime_list
-					     + _S_n_primes, __min_bkts);
-    _M_next_resize =
-      static_cast<std::size_t>(__builtin_ceil(*__p * _M_max_load_factor));
-    return *__p;
-  }
-
-  // Finds the smallest prime p such that alpha p > __n_elt + __n_ins.
-  // If p > __n_bkt, return make_pair(true, p); otherwise return
-  // make_pair(false, 0).  In principle this isn't very different from 
-  // _M_bkt_for_elements.
-
-  // The only tricky part is that we're caching the element count at
-  // which we need to rehash, so we don't have to do a floating-point
-  // multiply for every insertion.
-
-  inline std::pair<bool, std::size_t>
-  _Prime_rehash_policy::
-  _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
-		 std::size_t __n_ins) const
-  {
-    if (__n_elt + __n_ins > _M_next_resize)
-      {
-	float __min_bkts = ((float(__n_ins) + float(__n_elt))
-			    / _M_max_load_factor);
-	if (__min_bkts > __n_bkt)
-	  {
-	    __min_bkts = std::max(__min_bkts, _M_growth_factor * __n_bkt);
-	    const unsigned long* __p =
-	      __lower_bound(__prime_list, __prime_list + _S_n_primes,
-			    __min_bkts);
-	    _M_next_resize = static_cast<std::size_t>
-	      (__builtin_ceil(*__p * _M_max_load_factor));
-	    return std::make_pair(true, *__p);
-	  }
-	else 
-	  {
-	    _M_next_resize = static_cast<std::size_t>
-	      (__builtin_ceil(__n_bkt * _M_max_load_factor));
-	    return std::make_pair(false, 0);
-	  }
-      }
-    else
-      return std::make_pair(false, 0);
-  }
-
-  // Base classes for std::tr1::_Hashtable.  We define these base
-  // classes because in some cases we want to do different things
-  // depending on the value of a policy class.  In some cases the
-  // policy class affects which member functions and nested typedefs
-  // are defined; we handle that by specializing base class templates.
-  // Several of the base class templates need to access other members
-  // of class template _Hashtable, so we use the "curiously recurring
-  // template pattern" for them.
-
-  // class template _Map_base.  If the hashtable has a value type of the
-  // form pair<T1, T2> and a key extraction policy that returns the
-  // first part of the pair, the hashtable gets a mapped_type typedef.
-  // If it satisfies those criteria and also has unique keys, then it
-  // also gets an operator[].  
-  template<typename _Key, typename _Value, typename _Ex, bool __unique,
-	   typename _Hashtable>
-    struct _Map_base { };
-	  
-  template<typename _Key, typename _Pair, typename _Hashtable>
-    struct _Map_base<_Key, _Pair, std::_Select1st<_Pair>, false, _Hashtable>
-    {
-      typedef typename _Pair::second_type mapped_type;
-    };
-
-  template<typename _Key, typename _Pair, typename _Hashtable>
-    struct _Map_base<_Key, _Pair, std::_Select1st<_Pair>, true, _Hashtable>
-    {
-      typedef typename _Pair::second_type mapped_type;
-      
-      mapped_type&
-      operator[](const _Key& __k);
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      // _GLIBCXX_RESOLVE_LIB_DEFECTS
-      // DR 761. unordered_map needs an at() member function.
-      mapped_type&
-      at(const _Key& __k);
-
-      const mapped_type&
-      at(const _Key& __k) const;
-#endif
-    };
-
-  template<typename _Key, typename _Pair, typename _Hashtable>
-    typename _Map_base<_Key, _Pair, std::_Select1st<_Pair>,
-		       true, _Hashtable>::mapped_type&
-    _Map_base<_Key, _Pair, std::_Select1st<_Pair>, true, _Hashtable>::
-    operator[](const _Key& __k)
-    {
-      _Hashtable* __h = static_cast<_Hashtable*>(this);
-      typename _Hashtable::_Hash_code_type __code = __h->_M_hash_code(__k);
-      std::size_t __n = __h->_M_bucket_index(__k, __code,
-					     __h->_M_bucket_count);
-
-      typename _Hashtable::_Node* __p =
-	__h->_M_find_node(__h->_M_buckets[__n], __k, __code);
-      if (!__p)
-	return __h->_M_insert_bucket(std::make_pair(__k, mapped_type()),
-				     __n, __code)->second;
-      return (__p->_M_v).second;
-    }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-  template<typename _Key, typename _Pair, typename _Hashtable>
-    typename _Map_base<_Key, _Pair, std::_Select1st<_Pair>,
-		       true, _Hashtable>::mapped_type&
-    _Map_base<_Key, _Pair, std::_Select1st<_Pair>, true, _Hashtable>::
-    at(const _Key& __k)
-    {
-      _Hashtable* __h = static_cast<_Hashtable*>(this);
-      typename _Hashtable::_Hash_code_type __code = __h->_M_hash_code(__k);
-      std::size_t __n = __h->_M_bucket_index(__k, __code,
-					     __h->_M_bucket_count);
-
-      typename _Hashtable::_Node* __p =
-	__h->_M_find_node(__h->_M_buckets[__n], __k, __code);
-      if (!__p)
-	__throw_out_of_range(__N("_Map_base::at"));
-      return (__p->_M_v).second;
-    }
-
-  template<typename _Key, typename _Pair, typename _Hashtable>
-    const typename _Map_base<_Key, _Pair, std::_Select1st<_Pair>,
-			     true, _Hashtable>::mapped_type&
-    _Map_base<_Key, _Pair, std::_Select1st<_Pair>, true, _Hashtable>::
-    at(const _Key& __k) const
-    {
-      const _Hashtable* __h = static_cast<const _Hashtable*>(this);
-      typename _Hashtable::_Hash_code_type __code = __h->_M_hash_code(__k);
-      std::size_t __n = __h->_M_bucket_index(__k, __code,
-					     __h->_M_bucket_count);
-
-      typename _Hashtable::_Node* __p =
-	__h->_M_find_node(__h->_M_buckets[__n], __k, __code);
-      if (!__p)
-	__throw_out_of_range(__N("_Map_base::at"));
-      return (__p->_M_v).second;
-    }
-#endif
-
-  // class template _Rehash_base.  Give hashtable the max_load_factor
-  // functions iff the rehash policy is _Prime_rehash_policy.
-  template<typename _RehashPolicy, typename _Hashtable>
-    struct _Rehash_base { };
-
-  template<typename _Hashtable>
-    struct _Rehash_base<_Prime_rehash_policy, _Hashtable>
-    {
-      float
-      max_load_factor() const
-      {
-	const _Hashtable* __this = static_cast<const _Hashtable*>(this);
-	return __this->__rehash_policy().max_load_factor();
-      }
-
-      void
-      max_load_factor(float __z)
-      {
-	_Hashtable* __this = static_cast<_Hashtable*>(this);
-	__this->__rehash_policy(_Prime_rehash_policy(__z));
-      }
-    };
-
-  // Class template _Hash_code_base.  Encapsulates two policy issues that
-  // aren't quite orthogonal.
-  //   (1) the difference between using a ranged hash function and using
-  //       the combination of a hash function and a range-hashing function.
-  //       In the former case we don't have such things as hash codes, so
-  //       we have a dummy type as placeholder.
-  //   (2) Whether or not we cache hash codes.  Caching hash codes is
-  //       meaningless if we have a ranged hash function.
-  // We also put the key extraction and equality comparison function 
-  // objects here, for convenience.
-  
-  // Primary template: unused except as a hook for specializations.  
-  template<typename _Key, typename _Value,
-	   typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash,
-	   bool __cache_hash_code>
-    struct _Hash_code_base;
-
-  // Specialization: ranged hash function, no caching hash codes.  H1
-  // and H2 are provided but ignored.  We define a dummy hash code type.
-  template<typename _Key, typename _Value,
-	   typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash>
-    struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2,
-			   _Hash, false>
-    {
-    protected:
-      _Hash_code_base(const _ExtractKey& __ex, const _Equal& __eq,
-		      const _H1&, const _H2&, const _Hash& __h)
-      : _M_extract(__ex), _M_eq(__eq), _M_ranged_hash(__h) { }
-
-      typedef void* _Hash_code_type;
-  
-      _Hash_code_type
-      _M_hash_code(const _Key& __key) const
-      { return 0; }
-  
-      std::size_t
-      _M_bucket_index(const _Key& __k, _Hash_code_type,
-		      std::size_t __n) const
-      { return _M_ranged_hash(__k, __n); }
-
-      std::size_t
-      _M_bucket_index(const _Hash_node<_Value, false>* __p,
-		      std::size_t __n) const
-      { return _M_ranged_hash(_M_extract(__p->_M_v), __n); }
-  
-      bool
-      _M_compare(const _Key& __k, _Hash_code_type,
-		 _Hash_node<_Value, false>* __n) const
-      { return _M_eq(__k, _M_extract(__n->_M_v)); }
-
-      void
-      _M_store_code(_Hash_node<_Value, false>*, _Hash_code_type) const
-      { }
-
-      void
-      _M_copy_code(_Hash_node<_Value, false>*,
-		   const _Hash_node<_Value, false>*) const
-      { }
-      
-      void
-      _M_swap(_Hash_code_base& __x)
-      {
-	std::swap(_M_extract, __x._M_extract);
-	std::swap(_M_eq, __x._M_eq);
-	std::swap(_M_ranged_hash, __x._M_ranged_hash);
-      }
-
-    protected:
-      _ExtractKey  _M_extract;
-      _Equal       _M_eq;
-      _Hash        _M_ranged_hash;
-    };
-
-
-  // No specialization for ranged hash function while caching hash codes.
-  // That combination is meaningless, and trying to do it is an error.
-  
-  
-  // Specialization: ranged hash function, cache hash codes.  This
-  // combination is meaningless, so we provide only a declaration
-  // and no definition.  
-  template<typename _Key, typename _Value,
-	   typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2, typename _Hash>
-    struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2,
-			   _Hash, true>;
-
-  // Specialization: hash function and range-hashing function, no
-  // caching of hash codes.  H is provided but ignored.  Provides
-  // typedef and accessor required by TR1.  
-  template<typename _Key, typename _Value,
-	   typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2>
-    struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2,
-			   _Default_ranged_hash, false>
-    {
-      typedef _H1 hasher;
-
-      hasher
-      hash_function() const
-      { return _M_h1; }
-
-    protected:
-      _Hash_code_base(const _ExtractKey& __ex, const _Equal& __eq,
-		      const _H1& __h1, const _H2& __h2,
-		      const _Default_ranged_hash&)
-      : _M_extract(__ex), _M_eq(__eq), _M_h1(__h1), _M_h2(__h2) { }
-
-      typedef std::size_t _Hash_code_type;
-
-      _Hash_code_type
-      _M_hash_code(const _Key& __k) const
-      { return _M_h1(__k); }
-      
-      std::size_t
-      _M_bucket_index(const _Key&, _Hash_code_type __c,
-		      std::size_t __n) const
-      { return _M_h2(__c, __n); }
-
-      std::size_t
-      _M_bucket_index(const _Hash_node<_Value, false>* __p,
-		      std::size_t __n) const
-      { return _M_h2(_M_h1(_M_extract(__p->_M_v)), __n); }
-
-      bool
-      _M_compare(const _Key& __k, _Hash_code_type,
-		 _Hash_node<_Value, false>* __n) const
-      { return _M_eq(__k, _M_extract(__n->_M_v)); }
-
-      void
-      _M_store_code(_Hash_node<_Value, false>*, _Hash_code_type) const
-      { }
-
-      void
-      _M_copy_code(_Hash_node<_Value, false>*,
-		   const _Hash_node<_Value, false>*) const
-      { }
-
-      void
-      _M_swap(_Hash_code_base& __x)
-      {
-	std::swap(_M_extract, __x._M_extract);
-	std::swap(_M_eq, __x._M_eq);
-	std::swap(_M_h1, __x._M_h1);
-	std::swap(_M_h2, __x._M_h2);
-      }
-
-    protected:
-      _ExtractKey  _M_extract;
-      _Equal       _M_eq;
-      _H1          _M_h1;
-      _H2          _M_h2;
-    };
-
-  // Specialization: hash function and range-hashing function, 
-  // caching hash codes.  H is provided but ignored.  Provides
-  // typedef and accessor required by TR1.
-  template<typename _Key, typename _Value,
-	   typename _ExtractKey, typename _Equal,
-	   typename _H1, typename _H2>
-    struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2,
-			   _Default_ranged_hash, true>
-    {
-      typedef _H1 hasher;
-      
-      hasher
-      hash_function() const
-      { return _M_h1; }
-
-    protected:
-      _Hash_code_base(const _ExtractKey& __ex, const _Equal& __eq,
-		      const _H1& __h1, const _H2& __h2,
-		      const _Default_ranged_hash&)
-      : _M_extract(__ex), _M_eq(__eq), _M_h1(__h1), _M_h2(__h2) { }
-
-      typedef std::size_t _Hash_code_type;
-  
-      _Hash_code_type
-      _M_hash_code(const _Key& __k) const
-      { return _M_h1(__k); }
-  
-      std::size_t
-      _M_bucket_index(const _Key&, _Hash_code_type __c,
-		      std::size_t __n) const
-      { return _M_h2(__c, __n); }
-
-      std::size_t
-      _M_bucket_index(const _Hash_node<_Value, true>* __p,
-		      std::size_t __n) const
-      { return _M_h2(__p->_M_hash_code, __n); }
-
-      bool
-      _M_compare(const _Key& __k, _Hash_code_type __c,
-		 _Hash_node<_Value, true>* __n) const
-      { return __c == __n->_M_hash_code && _M_eq(__k, _M_extract(__n->_M_v)); }
-
-      void
-      _M_store_code(_Hash_node<_Value, true>* __n, _Hash_code_type __c) const
-      { __n->_M_hash_code = __c; }
-
-      void
-      _M_copy_code(_Hash_node<_Value, true>* __to,
-		   const _Hash_node<_Value, true>* __from) const
-      { __to->_M_hash_code = __from->_M_hash_code; }
-
-      void
-      _M_swap(_Hash_code_base& __x)
-      {
-	std::swap(_M_extract, __x._M_extract);
-	std::swap(_M_eq, __x._M_eq);
-	std::swap(_M_h1, __x._M_h1);
-	std::swap(_M_h2, __x._M_h2);
-      }
-      
-    protected:
-      _ExtractKey  _M_extract;
-      _Equal       _M_eq;
-      _H1          _M_h1;
-      _H2          _M_h2;
-    };
-} // namespace __detail
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/random b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/random
deleted file mode 100644
index 0cf4dc4cd..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/random
+++ /dev/null
@@ -1,2407 +0,0 @@
-// random number generation -*- C++ -*-
-
-// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/**
- * @file tr1_impl/random
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-  // [5.1] Random number generation
-
-  /**
-   * @defgroup tr1_random Random Number Generation
-   * @ingroup numerics
-   * A facility for generating random numbers on selected distributions.
-   * @{
-   */
-
-  /*
-   * Implementation-space details.
-   */
-  namespace __detail
-  {
-    template<typename _UIntType, int __w, 
-	     bool = __w < std::numeric_limits<_UIntType>::digits>
-      struct _Shift
-      { static const _UIntType __value = 0; };
-
-    template<typename _UIntType, int __w>
-      struct _Shift<_UIntType, __w, true>
-      { static const _UIntType __value = _UIntType(1) << __w; };
-
-    template<typename _Tp, _Tp __a, _Tp __c, _Tp __m, bool>
-      struct _Mod;
-
-    // Dispatch based on modulus value to prevent divide-by-zero compile-time
-    // errors when m == 0.
-    template<typename _Tp, _Tp __a, _Tp __c, _Tp __m>
-      inline _Tp
-      __mod(_Tp __x)
-      { return _Mod<_Tp, __a, __c, __m, __m == 0>::__calc(__x); }
-
-    typedef __gnu_cxx::__conditional_type<(sizeof(unsigned) == 4),
-		    unsigned, unsigned long>::__type _UInt32Type;
-
-    /*
-     * An adaptor class for converting the output of any Generator into
-     * the input for a specific Distribution.
-     */
-    template<typename _Engine, typename _Distribution>
-      struct _Adaptor
-      { 
-	typedef typename remove_reference<_Engine>::type _BEngine;
-	typedef typename _BEngine::result_type           _Engine_result_type;
-	typedef typename _Distribution::input_type       result_type;
-
-      public:
-	_Adaptor(const _Engine& __g)
-	: _M_g(__g) { }
-
-	result_type
-	min() const
-	{
-	  result_type __return_value;
-	  if (is_integral<_Engine_result_type>::value
-	      && is_integral<result_type>::value)
-	    __return_value = _M_g.min();
-	  else
-	    __return_value = result_type(0);
-	  return __return_value;
-	}
-
-	result_type
-	max() const
-	{
-	  result_type __return_value;
-	  if (is_integral<_Engine_result_type>::value
-	      && is_integral<result_type>::value)
-	    __return_value = _M_g.max();
-	  else if (!is_integral<result_type>::value)
-	    __return_value = result_type(1);
-	  else
-	    __return_value = std::numeric_limits<result_type>::max() - 1;
-	  return __return_value;
-	}
-
-	/*
-	 * Converts a value generated by the adapted random number generator
-	 * into a value in the input domain for the dependent random number
-	 * distribution.
-	 *
-	 * Because the type traits are compile time constants only the
-	 * appropriate clause of the if statements will actually be emitted
-	 * by the compiler.
-	 */
-	result_type
-	operator()()
-	{
-	  result_type __return_value;
-	  if (is_integral<_Engine_result_type>::value
-	      && is_integral<result_type>::value)
-	    __return_value = _M_g();
-	  else if (!is_integral<_Engine_result_type>::value
-		   && !is_integral<result_type>::value)
-	    __return_value = result_type(_M_g() - _M_g.min())
-	      / result_type(_M_g.max() - _M_g.min());
-	  else if (is_integral<_Engine_result_type>::value
-		   && !is_integral<result_type>::value)
-	    __return_value = result_type(_M_g() - _M_g.min())
-	      / result_type(_M_g.max() - _M_g.min() + result_type(1));
-	  else
-	    __return_value = (((_M_g() - _M_g.min()) 
-			       / (_M_g.max() - _M_g.min()))
-			      * std::numeric_limits<result_type>::max());
-	  return __return_value;
-	}
-
-      private:
-	_Engine _M_g;
-      };
-
-    // Specialization for _Engine*.
-    template<typename _Engine, typename _Distribution>
-      struct _Adaptor<_Engine*, _Distribution>
-      {
-	typedef typename _Engine::result_type      _Engine_result_type;
-	typedef typename _Distribution::input_type result_type;
-
-      public:
-	_Adaptor(_Engine* __g)
-	: _M_g(__g) { }
-
-	result_type
-	min() const
-	{
-	  result_type __return_value;
-	  if (is_integral<_Engine_result_type>::value
-	      && is_integral<result_type>::value)
-	    __return_value = _M_g->min();
-	  else
-	    __return_value = result_type(0);
-	  return __return_value;
-	}
-
-	result_type
-	max() const
-	{
-	  result_type __return_value;
-	  if (is_integral<_Engine_result_type>::value
-	      && is_integral<result_type>::value)
-	    __return_value = _M_g->max();
-	  else if (!is_integral<result_type>::value)
-	    __return_value = result_type(1);
-	  else
-	    __return_value = std::numeric_limits<result_type>::max() - 1;
-	  return __return_value;
-	}
-
-	result_type
-	operator()()
-	{
-	  result_type __return_value;
-	  if (is_integral<_Engine_result_type>::value
-	      && is_integral<result_type>::value)
-	    __return_value = (*_M_g)();
-	  else if (!is_integral<_Engine_result_type>::value
-		   && !is_integral<result_type>::value)
-	    __return_value = result_type((*_M_g)() - _M_g->min())
-	      / result_type(_M_g->max() - _M_g->min());
-	  else if (is_integral<_Engine_result_type>::value
-		   && !is_integral<result_type>::value)
-	    __return_value = result_type((*_M_g)() - _M_g->min())
-	      / result_type(_M_g->max() - _M_g->min() + result_type(1));
-	  else
-	    __return_value = ((((*_M_g)() - _M_g->min()) 
-			       / (_M_g->max() - _M_g->min()))
-			      * std::numeric_limits<result_type>::max());
-	  return __return_value;
-	}
-
-      private:
-	_Engine* _M_g;
-      };
-  } // namespace __detail
-
-  /**
-   * Produces random numbers on a given distribution function using a
-   * non-uniform random number generation engine.
-   *
-   * @todo the engine_value_type needs to be studied more carefully.
-   */
-  template<typename _Engine, typename _Dist>
-    class variate_generator
-    {
-      // Concept requirements.
-      __glibcxx_class_requires(_Engine, _CopyConstructibleConcept)
-      //  __glibcxx_class_requires(_Engine, _EngineConcept)
-      //  __glibcxx_class_requires(_Dist, _EngineConcept)
-
-    public:
-      typedef _Engine                                engine_type;
-      typedef __detail::_Adaptor<_Engine, _Dist>     engine_value_type;
-      typedef _Dist                                  distribution_type;
-      typedef typename _Dist::result_type            result_type;
-
-      // tr1:5.1.1 table 5.1 requirement
-      typedef typename __gnu_cxx::__enable_if<
-	is_arithmetic<result_type>::value, result_type>::__type _IsValidType;
-
-      /**
-       * Constructs a variate generator with the uniform random number
-       * generator @p __eng for the random distribution @p __dist.
-       *
-       * @throws Any exceptions which may thrown by the copy constructors of
-       * the @p _Engine or @p _Dist objects.
-       */
-      variate_generator(engine_type __eng, distribution_type __dist)
-      : _M_engine(__eng), _M_dist(__dist) { }
-
-      /**
-       * Gets the next generated value on the distribution.
-       */
-      result_type
-      operator()()
-      { return _M_dist(_M_engine); }
-
-      /**
-       * WTF?
-       */
-      template<typename _Tp>
-        result_type
-        operator()(_Tp __value)
-        { return _M_dist(_M_engine, __value); }
-
-      /**
-       * Gets a reference to the underlying uniform random number generator
-       * object.
-       */
-      engine_value_type&
-      engine()
-      { return _M_engine; }
-
-      /**
-       * Gets a const reference to the underlying uniform random number
-       * generator object.
-       */
-      const engine_value_type&
-      engine() const
-      { return _M_engine; }
-
-      /**
-       * Gets a reference to the underlying random distribution.
-       */
-      distribution_type&
-      distribution()
-      { return _M_dist; }
-
-      /**
-       * Gets a const reference to the underlying random distribution.
-       */
-      const distribution_type&
-      distribution() const
-      { return _M_dist; }
-
-      /**
-       * Gets the closed lower bound of the distribution interval.
-       */
-      result_type
-      min() const
-      { return this->distribution().min(); }
-
-      /**
-       * Gets the closed upper bound of the distribution interval.
-       */
-      result_type
-      max() const
-      { return this->distribution().max(); }
-
-    private:
-      engine_value_type _M_engine;
-      distribution_type _M_dist;
-    };
-
-
-  /**
-   * @defgroup tr1_random_generators Random Number Generators
-   * @ingroup tr1_random
-   *
-   * These classes define objects which provide random or pseudorandom
-   * numbers, either from a discrete or a continuous interval.  The
-   * random number generator supplied as a part of this library are
-   * all uniform random number generators which provide a sequence of
-   * random number uniformly distributed over their range.
-   *
-   * A number generator is a function object with an operator() that
-   * takes zero arguments and returns a number.
-   *
-   * A compliant random number generator must satisfy the following
-   * requirements.  <table border=1 cellpadding=10 cellspacing=0>
-   * <caption align=top>Random Number Generator Requirements</caption>
-   * <tr><td>To be documented.</td></tr> </table>
-   * 
-   * @{
-   */
-
-  /**
-   * @brief A model of a linear congruential random number generator.
-   *
-   * A random number generator that produces pseudorandom numbers using the
-   * linear function @f$x_{i+1}\leftarrow(ax_{i} + c) \bmod m @f$.
-   *
-   * The template parameter @p _UIntType must be an unsigned integral type
-   * large enough to store values up to (__m-1). If the template parameter
-   * @p __m is 0, the modulus @p __m used is
-   * std::numeric_limits<_UIntType>::max() plus 1. Otherwise, the template
-   * parameters @p __a and @p __c must be less than @p __m.
-   *
-   * The size of the state is @f$ 1 @f$.
-   */
-  template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-    class linear_congruential
-    {
-      __glibcxx_class_requires(_UIntType, _UnsignedIntegerConcept)
-      //  __glibcpp_class_requires(__a < __m && __c < __m)
-
-    public:
-      /** The type of the generated random value. */
-      typedef _UIntType result_type;
-
-      /** The multiplier. */
-      static const _UIntType multiplier = __a;
-      /** An increment. */
-      static const _UIntType increment = __c;
-      /** The modulus. */
-      static const _UIntType modulus = __m;
-
-      /**
-       * Constructs a %linear_congruential random number generator engine with
-       * seed @p __s.  The default seed value is 1.
-       *
-       * @param __s The initial seed value.
-       */
-      explicit
-      linear_congruential(unsigned long __x0 = 1)
-      { this->seed(__x0); }
-
-      /**
-       * Constructs a %linear_congruential random number generator engine
-       * seeded from the generator function @p __g.
-       *
-       * @param __g The seed generator function.
-       */
-      template<class _Gen>
-        linear_congruential(_Gen& __g)
-        { this->seed(__g); }
-
-      /**
-       * Reseeds the %linear_congruential random number generator engine
-       * sequence to the seed @g __s.
-       *
-       * @param __s The new seed.
-       */
-      void
-      seed(unsigned long __s = 1);
-
-      /**
-       * Reseeds the %linear_congruential random number generator engine
-       * sequence using values from the generator function @p __g.
-       *
-       * @param __g the seed generator function.
-       */
-      template<class _Gen>
-        void
-        seed(_Gen& __g)
-        { seed(__g, typename is_fundamental<_Gen>::type()); }
-
-      /**
-       * Gets the smallest possible value in the output range.
-       *
-       * The minimum depends on the @p __c parameter: if it is zero, the
-       * minimum generated must be > 0, otherwise 0 is allowed.
-       */
-      result_type
-      min() const
-      { return (__detail::__mod<_UIntType, 1, 0, __m>(__c) == 0) ? 1 : 0; }
-
-      /**
-       * Gets the largest possible value in the output range.
-       */
-      result_type
-      max() const
-      { return __m - 1; }
-
-      /**
-       * Gets the next random number in the sequence.
-       */
-      result_type
-      operator()();
-
-      /**
-       * Compares two linear congruential random number generator
-       * objects of the same type for equality.
-       *  
-       * @param __lhs A linear congruential random number generator object.
-       * @param __rhs Another linear congruential random number generator obj.
-       *
-       * @returns true if the two objects are equal, false otherwise.
-       */
-      friend bool
-      operator==(const linear_congruential& __lhs,
-		 const linear_congruential& __rhs)
-      { return __lhs._M_x == __rhs._M_x; }
-
-      /**
-       * Compares two linear congruential random number generator
-       * objects of the same type for inequality.
-       *
-       * @param __lhs A linear congruential random number generator object.
-       * @param __rhs Another linear congruential random number generator obj.
-       *
-       * @returns true if the two objects are not equal, false otherwise.
-       */
-      friend bool
-      operator!=(const linear_congruential& __lhs,
-		 const linear_congruential& __rhs)
-      { return !(__lhs == __rhs); }
-
-      /**
-       * Writes the textual representation of the state x(i) of x to @p __os.
-       *
-       * @param __os  The output stream.
-       * @param __lcr A % linear_congruential random number generator.
-       * @returns __os.
-       */
-      template<class _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
-	       _UIntType1 __m1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const linear_congruential<_UIntType1, __a1, __c1,
-		   __m1>& __lcr);
-
-      /**
-       * Sets the state of the engine by reading its textual
-       * representation from @p __is.
-       *
-       * The textual representation must have been previously written using an
-       * output stream whose imbued locale and whose type's template
-       * specialization arguments _CharT and _Traits were the same as those of
-       * @p __is.
-       *
-       * @param __is  The input stream.
-       * @param __lcr A % linear_congruential random number generator.
-       * @returns __is.
-       */
-      template<class _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
-	       _UIntType1 __m1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   linear_congruential<_UIntType1, __a1, __c1, __m1>& __lcr);
-
-    private:
-      template<class _Gen>
-        void
-        seed(_Gen& __g, true_type)
-        { return seed(static_cast<unsigned long>(__g)); }
-
-      template<class _Gen>
-        void
-        seed(_Gen& __g, false_type);
-
-      _UIntType _M_x;
-    };
-
-  /**
-   * The classic Minimum Standard rand0 of Lewis, Goodman, and Miller.
-   */
-  typedef linear_congruential<unsigned long, 16807, 0, 2147483647> minstd_rand0;
-
-  /**
-   * An alternative LCR (Lehmer Generator function) .
-   */
-  typedef linear_congruential<unsigned long, 48271, 0, 2147483647> minstd_rand;
-
-
-  /**
-   * A generalized feedback shift register discrete random number generator.
-   *
-   * This algorithm avoids multiplication and division and is designed to be
-   * friendly to a pipelined architecture.  If the parameters are chosen
-   * correctly, this generator will produce numbers with a very long period and
-   * fairly good apparent entropy, although still not cryptographically strong.
-   *
-   * The best way to use this generator is with the predefined mt19937 class.
-   *
-   * This algorithm was originally invented by Makoto Matsumoto and
-   * Takuji Nishimura.
-   *
-   * @var word_size   The number of bits in each element of the state vector.
-   * @var state_size  The degree of recursion.
-   * @var shift_size  The period parameter.
-   * @var mask_bits   The separation point bit index.
-   * @var parameter_a The last row of the twist matrix.
-   * @var output_u    The first right-shift tempering matrix parameter.
-   * @var output_s    The first left-shift tempering matrix parameter.
-   * @var output_b    The first left-shift tempering matrix mask.
-   * @var output_t    The second left-shift tempering matrix parameter.
-   * @var output_c    The second left-shift tempering matrix mask.
-   * @var output_l    The second right-shift tempering matrix parameter.
-   */
-  template<class _UIntType, int __w, int __n, int __m, int __r,
-	   _UIntType __a, int __u, int __s, _UIntType __b, int __t,
-	   _UIntType __c, int __l>
-    class mersenne_twister
-    {
-      __glibcxx_class_requires(_UIntType, _UnsignedIntegerConcept)
-
-    public:
-      // types
-      typedef _UIntType result_type;
-
-      // parameter values
-      static const int       word_size   = __w;
-      static const int       state_size  = __n;
-      static const int       shift_size  = __m;
-      static const int       mask_bits   = __r;
-      static const _UIntType parameter_a = __a;
-      static const int       output_u    = __u;
-      static const int       output_s    = __s;
-      static const _UIntType output_b    = __b;
-      static const int       output_t    = __t;
-      static const _UIntType output_c    = __c;
-      static const int       output_l    = __l;
-
-      // constructors and member function
-      mersenne_twister()
-      { seed(); }
-
-      explicit
-      mersenne_twister(unsigned long __value)
-      { seed(__value); }
-
-      template<class _Gen>
-        mersenne_twister(_Gen& __g)
-        { seed(__g); }
-
-      void
-      seed()
-      { seed(5489UL); }
-
-      void
-      seed(unsigned long __value);
-
-      template<class _Gen>
-        void
-        seed(_Gen& __g)
-        { seed(__g, typename is_fundamental<_Gen>::type()); }
-
-      result_type
-      min() const
-      { return 0; };
-
-      result_type
-      max() const
-      { return __detail::_Shift<_UIntType, __w>::__value - 1; }
-
-      result_type
-      operator()();
-
-      /**
-       * Compares two % mersenne_twister random number generator objects of
-       * the same type for equality.
-       *
-       * @param __lhs A % mersenne_twister random number generator object.
-       * @param __rhs Another % mersenne_twister random number generator
-       *              object.
-       *
-       * @returns true if the two objects are equal, false otherwise.
-       */
-      friend bool
-      operator==(const mersenne_twister& __lhs,
-		 const mersenne_twister& __rhs)
-      { return std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x); }
-
-      /**
-       * Compares two % mersenne_twister random number generator objects of
-       * the same type for inequality.
-       *
-       * @param __lhs A % mersenne_twister random number generator object.
-       * @param __rhs Another % mersenne_twister random number generator
-       *              object.
-       *
-       * @returns true if the two objects are not equal, false otherwise.
-       */
-      friend bool
-      operator!=(const mersenne_twister& __lhs,
-		 const mersenne_twister& __rhs)
-      { return !(__lhs == __rhs); }
-
-      /**
-       * Inserts the current state of a % mersenne_twister random number
-       * generator engine @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A % mersenne_twister random number generator engine.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<class _UIntType1, int __w1, int __n1, int __m1, int __r1,
-	       _UIntType1 __a1, int __u1, int __s1, _UIntType1 __b1, int __t1,
-	       _UIntType1 __c1, int __l1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const mersenne_twister<_UIntType1, __w1, __n1, __m1, __r1,
-		   __a1, __u1, __s1, __b1, __t1, __c1, __l1>& __x);
-
-      /**
-       * Extracts the current state of a % mersenne_twister random number
-       * generator engine @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A % mersenne_twister random number generator engine.
-       *
-       * @returns The input stream with the state of @p __x extracted or in
-       * an error state.
-       */
-      template<class _UIntType1, int __w1, int __n1, int __m1, int __r1,
-	       _UIntType1 __a1, int __u1, int __s1, _UIntType1 __b1, int __t1,
-	       _UIntType1 __c1, int __l1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   mersenne_twister<_UIntType1, __w1, __n1, __m1, __r1,
-		   __a1, __u1, __s1, __b1, __t1, __c1, __l1>& __x);
-
-    private:
-      template<class _Gen>
-        void
-        seed(_Gen& __g, true_type)
-        { return seed(static_cast<unsigned long>(__g)); }
-
-      template<class _Gen>
-        void
-        seed(_Gen& __g, false_type);
-
-      _UIntType _M_x[state_size];
-      int       _M_p;
-    };
-
-  /**
-   * The classic Mersenne Twister.
-   *
-   * Reference:
-   * M. Matsumoto and T. Nishimura, "Mersenne Twister: A 623-Dimensionally
-   * Equidistributed Uniform Pseudo-Random Number Generator", ACM Transactions
-   * on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30.
-   */
-  typedef mersenne_twister<
-    unsigned long, 32, 624, 397, 31,
-    0x9908b0dful, 11, 7,
-    0x9d2c5680ul, 15,
-    0xefc60000ul, 18
-    > mt19937;
-
-
-  /**
-   * @brief The Marsaglia-Zaman generator.
-   * 
-   * This is a model of a Generalized Fibonacci discrete random number
-   * generator, sometimes referred to as the SWC generator.
-   *
-   * A discrete random number generator that produces pseudorandom
-   * numbers using @f$x_{i}\leftarrow(x_{i - s} - x_{i - r} -
-   * carry_{i-1}) \bmod m @f$.
-   *
-   * The size of the state is @f$ r @f$
-   * and the maximum period of the generator is @f$ m^r - m^s -1 @f$.
-   *
-   * N1688[4.13] says "the template parameter _IntType shall denote an integral
-   * type large enough to store values up to m."
-   *
-   * @var _M_x     The state of the generator.  This is a ring buffer.
-   * @var _M_carry The carry.
-   * @var _M_p     Current index of x(i - r).
-   */
-  template<typename _IntType, _IntType __m, int __s, int __r>
-    class subtract_with_carry
-    {
-      __glibcxx_class_requires(_IntType, _IntegerConcept)
-
-    public:
-      /** The type of the generated random value. */
-      typedef _IntType result_type;
-      
-      // parameter values
-      static const _IntType modulus   = __m;
-      static const int      long_lag  = __r;
-      static const int      short_lag = __s;
-
-      /**
-       * Constructs a default-initialized % subtract_with_carry random number
-       * generator.
-       */
-      subtract_with_carry()
-      { this->seed(); }
-
-      /**
-       * Constructs an explicitly seeded % subtract_with_carry random number
-       * generator.
-       */
-      explicit
-      subtract_with_carry(unsigned long __value)
-      { this->seed(__value); }
-
-      /**
-       * Constructs a %subtract_with_carry random number generator engine
-       * seeded from the generator function @p __g.
-       *
-       * @param __g The seed generator function.
-       */
-      template<class _Gen>
-        subtract_with_carry(_Gen& __g)
-        { this->seed(__g); }
-
-      /**
-       * Seeds the initial state @f$ x_0 @f$ of the random number generator.
-       *
-       * N1688[4.19] modifies this as follows.  If @p __value == 0,
-       * sets value to 19780503.  In any case, with a linear
-       * congruential generator lcg(i) having parameters @f$ m_{lcg} =
-       * 2147483563, a_{lcg} = 40014, c_{lcg} = 0, and lcg(0) = value
-       * @f$, sets @f$ x_{-r} \dots x_{-1} @f$ to @f$ lcg(1) \bmod m
-       * \dots lcg(r) \bmod m @f$ respectively.  If @f$ x_{-1} = 0 @f$
-       * set carry to 1, otherwise sets carry to 0.
-       */
-      void
-      seed(unsigned long __value = 19780503);
-
-      /**
-       * Seeds the initial state @f$ x_0 @f$ of the % subtract_with_carry
-       * random number generator.
-       */
-      template<class _Gen>
-        void
-        seed(_Gen& __g)
-        { seed(__g, typename is_fundamental<_Gen>::type()); }
-
-      /**
-       * Gets the inclusive minimum value of the range of random integers
-       * returned by this generator.
-       */
-      result_type
-      min() const
-      { return 0; }
-
-      /**
-       * Gets the inclusive maximum value of the range of random integers
-       * returned by this generator.
-       */
-      result_type
-      max() const
-      { return this->modulus - 1; }
-
-      /**
-       * Gets the next random number in the sequence.
-       */
-      result_type
-      operator()();
-
-      /**
-       * Compares two % subtract_with_carry random number generator objects of
-       * the same type for equality.
-       *
-       * @param __lhs A % subtract_with_carry random number generator object.
-       * @param __rhs Another % subtract_with_carry random number generator
-       *              object.
-       *
-       * @returns true if the two objects are equal, false otherwise.
-       */
-      friend bool
-      operator==(const subtract_with_carry& __lhs,
-		 const subtract_with_carry& __rhs)
-      { return std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x); }
-
-      /**
-       * Compares two % subtract_with_carry random number generator objects of
-       * the same type for inequality.
-       *
-       * @param __lhs A % subtract_with_carry random number generator object.
-       * @param __rhs Another % subtract_with_carry random number generator
-       *              object.
-       *
-       * @returns true if the two objects are not equal, false otherwise.
-       */
-      friend bool
-      operator!=(const subtract_with_carry& __lhs,
-		 const subtract_with_carry& __rhs)
-      { return !(__lhs == __rhs); }
-
-      /**
-       * Inserts the current state of a % subtract_with_carry random number
-       * generator engine @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A % subtract_with_carry random number generator engine.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _IntType1, _IntType1 __m1, int __s1, int __r1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const subtract_with_carry<_IntType1, __m1, __s1,
-		   __r1>& __x);
-
-      /**
-       * Extracts the current state of a % subtract_with_carry random number
-       * generator engine @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A % subtract_with_carry random number generator engine.
-       *
-       * @returns The input stream with the state of @p __x extracted or in
-       * an error state.
-       */
-      template<typename _IntType1, _IntType1 __m1, int __s1, int __r1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   subtract_with_carry<_IntType1, __m1, __s1, __r1>& __x);
-
-    private:
-      template<class _Gen>
-        void
-        seed(_Gen& __g, true_type)
-        { return seed(static_cast<unsigned long>(__g)); }
-
-      template<class _Gen>
-        void
-        seed(_Gen& __g, false_type);
-
-      typedef typename __gnu_cxx::__add_unsigned<_IntType>::__type _UIntType;
-
-      _UIntType  _M_x[long_lag];
-      _UIntType  _M_carry;
-      int        _M_p;
-    };
-
-
-  /**
-   * @brief The Marsaglia-Zaman generator (floats version).
-   *
-   * @var _M_x     The state of the generator.  This is a ring buffer.
-   * @var _M_carry The carry.
-   * @var _M_p     Current index of x(i - r).
-   * @var _M_npows Precomputed negative powers of 2.   
-   */
-  template<typename _RealType, int __w, int __s, int __r>
-    class subtract_with_carry_01
-    {
-    public:
-      /** The type of the generated random value. */
-      typedef _RealType result_type;
-      
-      // parameter values
-      static const int      word_size = __w;
-      static const int      long_lag  = __r;
-      static const int      short_lag = __s;
-
-      /**
-       * Constructs a default-initialized % subtract_with_carry_01 random
-       * number generator.
-       */
-      subtract_with_carry_01()
-      {
-	this->seed();
-	_M_initialize_npows();
-      }
-
-      /**
-       * Constructs an explicitly seeded % subtract_with_carry_01 random number
-       * generator.
-       */
-      explicit
-      subtract_with_carry_01(unsigned long __value)
-      {
-	this->seed(__value);
-	_M_initialize_npows();
-      }
-
-      /**
-       * Constructs a % subtract_with_carry_01 random number generator engine
-       * seeded from the generator function @p __g.
-       *
-       * @param __g The seed generator function.
-       */
-      template<class _Gen>
-        subtract_with_carry_01(_Gen& __g)
-        {
-	  this->seed(__g);
-	  _M_initialize_npows();	  
-	}
-
-      /**
-       * Seeds the initial state @f$ x_0 @f$ of the random number generator.
-       */
-      void
-      seed(unsigned long __value = 19780503);
-
-      /**
-       * Seeds the initial state @f$ x_0 @f$ of the % subtract_with_carry_01
-       * random number generator.
-       */
-      template<class _Gen>
-        void
-        seed(_Gen& __g)
-        { seed(__g, typename is_fundamental<_Gen>::type()); }
-
-      /**
-       * Gets the minimum value of the range of random floats
-       * returned by this generator.
-       */
-      result_type
-      min() const
-      { return 0.0; }
-
-      /**
-       * Gets the maximum value of the range of random floats
-       * returned by this generator.
-       */
-      result_type
-      max() const
-      { return 1.0; }
-
-      /**
-       * Gets the next random number in the sequence.
-       */
-      result_type
-      operator()();
-
-      /**
-       * Compares two % subtract_with_carry_01 random number generator objects
-       * of the same type for equality.
-       *
-       * @param __lhs A % subtract_with_carry_01 random number
-       *              generator object.
-       * @param __rhs Another % subtract_with_carry_01 random number generator
-       *              object.
-       *
-       * @returns true if the two objects are equal, false otherwise.
-       */
-      friend bool
-      operator==(const subtract_with_carry_01& __lhs,
-		 const subtract_with_carry_01& __rhs)
-      {
-	for (int __i = 0; __i < long_lag; ++__i)
-	  if (!std::equal(__lhs._M_x[__i], __lhs._M_x[__i] + __n,
-			  __rhs._M_x[__i]))
-	    return false;
-	return true;
-      }
-
-      /**
-       * Compares two % subtract_with_carry_01 random number generator objects
-       * of the same type for inequality.
-       *
-       * @param __lhs A % subtract_with_carry_01 random number
-       *              generator object.
-       *
-       * @param __rhs Another % subtract_with_carry_01 random number generator
-       *              object.
-       *
-       * @returns true if the two objects are not equal, false otherwise.
-       */
-      friend bool
-      operator!=(const subtract_with_carry_01& __lhs,
-		 const subtract_with_carry_01& __rhs)
-      { return !(__lhs == __rhs); }
-
-      /**
-       * Inserts the current state of a % subtract_with_carry_01 random number
-       * generator engine @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A % subtract_with_carry_01 random number generator engine.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _RealType1, int __w1, int __s1, int __r1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const subtract_with_carry_01<_RealType1, __w1, __s1,
-		   __r1>& __x);
-
-      /**
-       * Extracts the current state of a % subtract_with_carry_01 random number
-       * generator engine @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A % subtract_with_carry_01 random number generator engine.
-       *
-       * @returns The input stream with the state of @p __x extracted or in
-       * an error state.
-       */
-      template<typename _RealType1, int __w1, int __s1, int __r1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   subtract_with_carry_01<_RealType1, __w1, __s1, __r1>& __x);
-
-    private:
-      template<class _Gen>
-        void
-        seed(_Gen& __g, true_type)
-        { return seed(static_cast<unsigned long>(__g)); }
-
-      template<class _Gen>
-        void
-        seed(_Gen& __g, false_type);
-
-      void
-      _M_initialize_npows();
-
-      static const int __n = (__w + 31) / 32;
-
-      typedef __detail::_UInt32Type _UInt32Type;
-      _UInt32Type  _M_x[long_lag][__n];
-      _RealType    _M_npows[__n];
-      _UInt32Type  _M_carry;
-      int          _M_p;
-    };
-
-  typedef subtract_with_carry_01<float, 24, 10, 24>   ranlux_base_01;
-
-  // _GLIBCXX_RESOLVE_LIB_DEFECTS
-  // 508. Bad parameters for ranlux64_base_01.
-  typedef subtract_with_carry_01<double, 48, 5, 12> ranlux64_base_01;  
-
-
-  /**
-   * Produces random numbers from some base engine by discarding blocks of
-   * data.
-   *
-   * 0 <= @p __r <= @p __p
-   */
-  template<class _UniformRandomNumberGenerator, int __p, int __r>
-    class discard_block
-    {
-      // __glibcxx_class_requires(typename base_type::result_type,
-      //                          ArithmeticTypeConcept)
-
-    public:
-      /** The type of the underlying generator engine. */
-      typedef _UniformRandomNumberGenerator   base_type;
-      /** The type of the generated random value. */
-      typedef typename base_type::result_type result_type;
-
-      // parameter values
-      static const int block_size = __p;
-      static const int used_block = __r;
-
-      /**
-       * Constructs a default %discard_block engine.
-       *
-       * The underlying engine is default constructed as well.
-       */
-      discard_block()
-      : _M_n(0) { }
-
-      /**
-       * Copy constructs a %discard_block engine.
-       *
-       * Copies an existing base class random number generator.
-       * @param rng An existing (base class) engine object.
-       */
-      explicit
-      discard_block(const base_type& __rng)
-      : _M_b(__rng), _M_n(0) { }
-
-      /**
-       * Seed constructs a %discard_block engine.
-       *
-       * Constructs the underlying generator engine seeded with @p __s.
-       * @param __s A seed value for the base class engine.
-       */
-      explicit
-      discard_block(unsigned long __s)
-      : _M_b(__s), _M_n(0) { }
-
-      /**
-       * Generator construct a %discard_block engine.
-       *
-       * @param __g A seed generator function.
-       */
-      template<class _Gen>
-        discard_block(_Gen& __g)
-	: _M_b(__g), _M_n(0) { }
-
-      /**
-       * Reseeds the %discard_block object with the default seed for the
-       * underlying base class generator engine.
-       */
-      void seed()
-      {
-	_M_b.seed();
-	_M_n = 0;
-      }
-
-      /**
-       * Reseeds the %discard_block object with the given seed generator
-       * function.
-       * @param __g A seed generator function.
-       */
-      template<class _Gen>
-        void seed(_Gen& __g)
-        {
-	  _M_b.seed(__g);
-	  _M_n = 0;
-	}
-
-      /**
-       * Gets a const reference to the underlying generator engine object.
-       */
-      const base_type&
-      base() const
-      { return _M_b; }
-
-      /**
-       * Gets the minimum value in the generated random number range.
-       */
-      result_type
-      min() const
-      { return _M_b.min(); }
-
-      /**
-       * Gets the maximum value in the generated random number range.
-       */
-      result_type
-      max() const
-      { return _M_b.max(); }
-
-      /**
-       * Gets the next value in the generated random number sequence.
-       */
-      result_type
-      operator()();
-
-      /**
-       * Compares two %discard_block random number generator objects of
-       * the same type for equality.
-       *
-       * @param __lhs A %discard_block random number generator object.
-       * @param __rhs Another %discard_block random number generator
-       *              object.
-       *
-       * @returns true if the two objects are equal, false otherwise.
-       */
-      friend bool
-      operator==(const discard_block& __lhs, const discard_block& __rhs)
-      { return (__lhs._M_b == __rhs._M_b) && (__lhs._M_n == __rhs._M_n); }
-
-      /**
-       * Compares two %discard_block random number generator objects of
-       * the same type for inequality.
-       *
-       * @param __lhs A %discard_block random number generator object.
-       * @param __rhs Another %discard_block random number generator
-       *              object.
-       *
-       * @returns true if the two objects are not equal, false otherwise.
-       */
-      friend bool
-      operator!=(const discard_block& __lhs, const discard_block& __rhs)
-      { return !(__lhs == __rhs); }
-
-      /**
-       * Inserts the current state of a %discard_block random number
-       * generator engine @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %discard_block random number generator engine.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<class _UniformRandomNumberGenerator1, int __p1, int __r1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const discard_block<_UniformRandomNumberGenerator1,
-		   __p1, __r1>& __x);
-
-      /**
-       * Extracts the current state of a % subtract_with_carry random number
-       * generator engine @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A %discard_block random number generator engine.
-       *
-       * @returns The input stream with the state of @p __x extracted or in
-       * an error state.
-       */
-      template<class _UniformRandomNumberGenerator1, int __p1, int __r1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   discard_block<_UniformRandomNumberGenerator1,
-		   __p1, __r1>& __x);
-
-    private:
-      base_type _M_b;
-      int       _M_n;
-    };
-
-
-  /**
-   * James's luxury-level-3 integer adaptation of Luescher's generator.
-   */
-  typedef discard_block<
-    subtract_with_carry<unsigned long, (1UL << 24), 10, 24>,
-      223,
-      24
-      > ranlux3;
-
-  /**
-   * James's luxury-level-4 integer adaptation of Luescher's generator.
-   */
-  typedef discard_block<
-    subtract_with_carry<unsigned long, (1UL << 24), 10, 24>,
-      389,
-      24
-      > ranlux4;
-
-  typedef discard_block<
-    subtract_with_carry_01<float, 24, 10, 24>,
-      223,
-      24
-      > ranlux3_01;
-
-  typedef discard_block<
-    subtract_with_carry_01<float, 24, 10, 24>,
-      389,
-      24
-      > ranlux4_01;
-
-
-  /**
-   * A random number generator adaptor class that combines two random number
-   * generator engines into a single output sequence.
-   */
-  template<class _UniformRandomNumberGenerator1, int __s1,
-	   class _UniformRandomNumberGenerator2, int __s2>
-    class xor_combine
-    {
-      // __glibcxx_class_requires(typename _UniformRandomNumberGenerator1::
-      //                          result_type, ArithmeticTypeConcept)
-      // __glibcxx_class_requires(typename _UniformRandomNumberGenerator2::
-      //                          result_type, ArithmeticTypeConcept)
-
-    public:
-      /** The type of the first underlying generator engine. */
-      typedef _UniformRandomNumberGenerator1   base1_type;
-      /** The type of the second underlying generator engine. */
-      typedef _UniformRandomNumberGenerator2   base2_type;
-
-    private:
-      typedef typename base1_type::result_type _Result_type1;
-      typedef typename base2_type::result_type _Result_type2;
-
-    public:
-      /** The type of the generated random value. */
-      typedef typename __gnu_cxx::__conditional_type<(sizeof(_Result_type1)
-						      > sizeof(_Result_type2)),
-	_Result_type1, _Result_type2>::__type result_type;
-
-      // parameter values
-      static const int shift1 = __s1;
-      static const int shift2 = __s2;
-
-      // constructors and member function
-      xor_combine()
-      : _M_b1(), _M_b2()	
-      { _M_initialize_max(); }
-
-      xor_combine(const base1_type& __rng1, const base2_type& __rng2)
-      : _M_b1(__rng1), _M_b2(__rng2)
-      { _M_initialize_max(); }
-
-      xor_combine(unsigned long __s)
-      : _M_b1(__s), _M_b2(__s + 1)
-      { _M_initialize_max(); }
-
-      template<class _Gen>
-        xor_combine(_Gen& __g)
-	: _M_b1(__g), _M_b2(__g)
-        { _M_initialize_max(); }
-
-      void
-      seed()
-      {
-	_M_b1.seed();
-	_M_b2.seed();
-      }
-
-      template<class _Gen>
-        void
-        seed(_Gen& __g)
-        {
-	  _M_b1.seed(__g);
-	  _M_b2.seed(__g);
-	}
-
-      const base1_type&
-      base1() const
-      { return _M_b1; }
-
-      const base2_type&
-      base2() const
-      { return _M_b2; }
-
-      result_type
-      min() const
-      { return 0; }
-
-      result_type
-      max() const
-      { return _M_max; }
-
-      /**
-       * Gets the next random number in the sequence.
-       */
-      // NB: Not exactly the TR1 formula, per N2079 instead.
-      result_type
-      operator()()
-      {
-	return ((result_type(_M_b1() - _M_b1.min()) << shift1)
-		^ (result_type(_M_b2() - _M_b2.min()) << shift2));
-      }
-
-      /**
-       * Compares two %xor_combine random number generator objects of
-       * the same type for equality.
-       *
-       * @param __lhs A %xor_combine random number generator object.
-       * @param __rhs Another %xor_combine random number generator
-       *              object.
-       *
-       * @returns true if the two objects are equal, false otherwise.
-       */
-      friend bool
-      operator==(const xor_combine& __lhs, const xor_combine& __rhs)
-      {
-	return (__lhs.base1() == __rhs.base1())
-	        && (__lhs.base2() == __rhs.base2());
-      }
-
-      /**
-       * Compares two %xor_combine random number generator objects of
-       * the same type for inequality.
-       *
-       * @param __lhs A %xor_combine random number generator object.
-       * @param __rhs Another %xor_combine random number generator
-       *              object.
-       *
-       * @returns true if the two objects are not equal, false otherwise.
-       */
-      friend bool
-      operator!=(const xor_combine& __lhs, const xor_combine& __rhs)
-      { return !(__lhs == __rhs); }
-
-      /**
-       * Inserts the current state of a %xor_combine random number
-       * generator engine @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %xor_combine random number generator engine.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<class _UniformRandomNumberGenerator11, int __s11,
-	       class _UniformRandomNumberGenerator21, int __s21,
-	       typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const xor_combine<_UniformRandomNumberGenerator11, __s11,
-		   _UniformRandomNumberGenerator21, __s21>& __x);
-
-      /**
-       * Extracts the current state of a %xor_combine random number
-       * generator engine @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A %xor_combine random number generator engine.
-       *
-       * @returns The input stream with the state of @p __x extracted or in
-       * an error state.
-       */
-      template<class _UniformRandomNumberGenerator11, int __s11,
-	       class _UniformRandomNumberGenerator21, int __s21,
-	       typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   xor_combine<_UniformRandomNumberGenerator11, __s11,
-		   _UniformRandomNumberGenerator21, __s21>& __x);
-
-    private:
-      void
-      _M_initialize_max();
-
-      result_type
-      _M_initialize_max_aux(result_type, result_type, int);
-
-      base1_type  _M_b1;
-      base2_type  _M_b2;
-      result_type _M_max;
-    };
-
-
-  /**
-   * A standard interface to a platform-specific non-deterministic
-   * random number generator (if any are available).
-   */
-  class random_device
-  {
-  public:
-    // types
-    typedef unsigned int result_type;
-
-    // constructors, destructors and member functions
-
-#ifdef _GLIBCXX_USE_RANDOM_TR1
-
-    explicit
-    random_device(const std::string& __token = "/dev/urandom")
-    {
-      if ((__token != "/dev/urandom" && __token != "/dev/random")
-	  || !(_M_file = std::fopen(__token.c_str(), "rb")))
-	std::__throw_runtime_error(__N("random_device::"
-				       "random_device(const std::string&)"));
-    }
-
-    ~random_device()
-    { std::fclose(_M_file); }
-
-#else
-
-    explicit
-    random_device(const std::string& __token = "mt19937")
-    : _M_mt(_M_strtoul(__token)) { }
-
-  private:
-    static unsigned long
-    _M_strtoul(const std::string& __str)
-    {
-      unsigned long __ret = 5489UL;
-      if (__str != "mt19937")
-	{
-	  const char* __nptr = __str.c_str();
-	  char* __endptr;
-	  __ret = std::strtoul(__nptr, &__endptr, 0);
-	  if (*__nptr == '\0' || *__endptr != '\0')
-	    std::__throw_runtime_error(__N("random_device::_M_strtoul"
-					   "(const std::string&)"));
-	}
-      return __ret;
-    }
-
-  public:
-
-#endif
-
-    result_type
-    min() const
-    { return std::numeric_limits<result_type>::min(); }
-
-    result_type
-    max() const
-    { return std::numeric_limits<result_type>::max(); }
-
-    double
-    entropy() const
-    { return 0.0; }
-
-    result_type
-    operator()()
-    {
-#ifdef _GLIBCXX_USE_RANDOM_TR1
-      result_type __ret;
-      std::fread(reinterpret_cast<void*>(&__ret), sizeof(result_type),
-		 1, _M_file);
-      return __ret;
-#else
-      return _M_mt();
-#endif
-    }
-
-  private:
-    random_device(const random_device&);
-    void operator=(const random_device&);
-
-#ifdef _GLIBCXX_USE_RANDOM_TR1
-    FILE*        _M_file;
-#else
-    mt19937      _M_mt;
-#endif
-  };
-
-  /* @} */ // group tr1_random_generators
-
-  /**
-   * @defgroup tr1_random_distributions Random Number Distributions
-   * @ingroup tr1_random
-   * @{
-   */
-
-  /**
-   * @defgroup tr1_random_distributions_discrete Discrete Distributions
-   * @ingroup tr1_random_distributions
-   * @{
-   */
-
-  /**
-   * @brief Uniform discrete distribution for random numbers.
-   * A discrete random distribution on the range @f$[min, max]@f$ with equal
-   * probability throughout the range.
-   */
-  template<typename _IntType = int>
-    class uniform_int
-    {
-      __glibcxx_class_requires(_IntType, _IntegerConcept)
- 
-    public:
-      /** The type of the parameters of the distribution. */
-      typedef _IntType input_type;
-      /** The type of the range of the distribution. */
-      typedef _IntType result_type;
-
-    public:
-      /**
-       * Constructs a uniform distribution object.
-       */
-      explicit
-      uniform_int(_IntType __min = 0, _IntType __max = 9)
-      : _M_min(__min), _M_max(__max)
-      {
-	_GLIBCXX_DEBUG_ASSERT(_M_min <= _M_max);
-      }
-
-      /**
-       * Gets the inclusive lower bound of the distribution range.
-       */
-      result_type
-      min() const
-      { return _M_min; }
-
-      /**
-       * Gets the inclusive upper bound of the distribution range.
-       */
-      result_type
-      max() const
-      { return _M_max; }
-
-      /**
-       * Resets the distribution state.
-       *
-       * Does nothing for the uniform integer distribution.
-       */
-      void
-      reset() { }
-
-      /**
-       * Gets a uniformly distributed random number in the range
-       * @f$(min, max)@f$.
-       */
-      template<typename _UniformRandomNumberGenerator>
-        result_type
-        operator()(_UniformRandomNumberGenerator& __urng)
-        {
-	  typedef typename _UniformRandomNumberGenerator::result_type
-	    _UResult_type;
-	  return _M_call(__urng, _M_min, _M_max,
-			 typename is_integral<_UResult_type>::type());
-	}
-
-      /**
-       * Gets a uniform random number in the range @f$[0, n)@f$.
-       *
-       * This function is aimed at use with std::random_shuffle.
-       */
-      template<typename _UniformRandomNumberGenerator>
-        result_type
-        operator()(_UniformRandomNumberGenerator& __urng, result_type __n)
-        {
-	  typedef typename _UniformRandomNumberGenerator::result_type
-	    _UResult_type;
-	  return _M_call(__urng, 0, __n - 1,
-			 typename is_integral<_UResult_type>::type());
-	}
-
-      /**
-       * Inserts a %uniform_int random number distribution @p __x into the
-       * output stream @p os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %uniform_int random number distribution.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _IntType1, typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const uniform_int<_IntType1>& __x);
-
-      /**
-       * Extracts a %uniform_int random number distribution
-       * @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A %uniform_int random number generator engine.
-       *
-       * @returns The input stream with @p __x extracted or in an error state.
-       */
-      template<typename _IntType1, typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   uniform_int<_IntType1>& __x);
-
-    private:
-      template<typename _UniformRandomNumberGenerator>
-        result_type
-        _M_call(_UniformRandomNumberGenerator& __urng,
-		result_type __min, result_type __max, true_type);
-
-      template<typename _UniformRandomNumberGenerator>
-        result_type
-        _M_call(_UniformRandomNumberGenerator& __urng,
-		result_type __min, result_type __max, false_type)
-        {
-	  return result_type((__urng() - __urng.min())
-			     / (__urng.max() - __urng.min())
-			     * (__max - __min + 1)) + __min;
-	}
-
-      _IntType _M_min;
-      _IntType _M_max;
-    };
-
-
-  /**
-   * @brief A Bernoulli random number distribution.
-   *
-   * Generates a sequence of true and false values with likelihood @f$ p @f$
-   * that true will come up and @f$ (1 - p) @f$ that false will appear.
-   */
-  class bernoulli_distribution
-  {
-  public:
-    typedef int  input_type;
-    typedef bool result_type;
-
-  public:
-    /**
-     * Constructs a Bernoulli distribution with likelihood @p p.
-     *
-     * @param __p  [IN]  The likelihood of a true result being returned.  Must
-     * be in the interval @f$ [0, 1] @f$.
-     */
-    explicit
-    bernoulli_distribution(double __p = 0.5)
-    : _M_p(__p)
-    { 
-      _GLIBCXX_DEBUG_ASSERT((_M_p >= 0.0) && (_M_p <= 1.0));
-    }
-
-    /**
-     * Gets the @p p parameter of the distribution.
-     */
-    double
-    p() const
-    { return _M_p; }
-
-    /**
-     * Resets the distribution state.
-     *
-     * Does nothing for a Bernoulli distribution.
-     */
-    void
-    reset() { }
-
-    /**
-     * Gets the next value in the Bernoullian sequence.
-     */
-    template<class _UniformRandomNumberGenerator>
-      result_type
-      operator()(_UniformRandomNumberGenerator& __urng)
-      {
-	if ((__urng() - __urng.min()) < _M_p * (__urng.max() - __urng.min()))
-	  return true;
-	return false;
-      }
-
-    /**
-     * Inserts a %bernoulli_distribution random number distribution
-     * @p __x into the output stream @p __os.
-     *
-     * @param __os An output stream.
-     * @param __x  A %bernoulli_distribution random number distribution.
-     *
-     * @returns The output stream with the state of @p __x inserted or in
-     * an error state.
-     */
-    template<typename _CharT, typename _Traits>
-      friend std::basic_ostream<_CharT, _Traits>&
-      operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		 const bernoulli_distribution& __x);
-
-    /**
-     * Extracts a %bernoulli_distribution random number distribution
-     * @p __x from the input stream @p __is.
-     *
-     * @param __is An input stream.
-     * @param __x  A %bernoulli_distribution random number generator engine.
-     *
-     * @returns The input stream with @p __x extracted or in an error state.
-     */
-    template<typename _CharT, typename _Traits>
-      friend std::basic_istream<_CharT, _Traits>&
-      operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		 bernoulli_distribution& __x)
-      { return __is >> __x._M_p; }
-
-  private:
-    double _M_p;
-  };
-
-
-  /**
-   * @brief A discrete geometric random number distribution.
-   *
-   * The formula for the geometric probability mass function is 
-   * @f$ p(i) = (1 - p)p^{i-1} @f$ where @f$ p @f$ is the parameter of the
-   * distribution.
-   */
-  template<typename _IntType = int, typename _RealType = double>
-    class geometric_distribution
-    {
-    public:
-      // types
-      typedef _RealType input_type;
-      typedef _IntType  result_type;
-
-      // constructors and member function
-      explicit
-      geometric_distribution(const _RealType& __p = _RealType(0.5))
-      : _M_p(__p)
-      {
-	_GLIBCXX_DEBUG_ASSERT((_M_p > 0.0) && (_M_p < 1.0));
-	_M_initialize();
-      }
-
-      /**
-       * Gets the distribution parameter @p p.
-       */
-      _RealType
-      p() const
-      { return _M_p; }
-
-      void
-      reset() { }
-
-      template<class _UniformRandomNumberGenerator>
-        result_type
-        operator()(_UniformRandomNumberGenerator& __urng);
-
-      /**
-       * Inserts a %geometric_distribution random number distribution
-       * @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %geometric_distribution random number distribution.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _IntType1, typename _RealType1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const geometric_distribution<_IntType1, _RealType1>& __x);
-
-      /**
-       * Extracts a %geometric_distribution random number distribution
-       * @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A %geometric_distribution random number generator engine.
-       *
-       * @returns The input stream with @p __x extracted or in an error state.
-       */
-      template<typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   geometric_distribution& __x)
-        {
-	  __is >> __x._M_p;
-	  __x._M_initialize();
-	  return __is;
-	}
-
-    private:
-      void
-      _M_initialize()
-      { _M_log_p = std::log(_M_p); }
-
-      _RealType _M_p;
-      _RealType _M_log_p;
-    };
-
-
-  template<typename _RealType>
-    class normal_distribution;
-
-  /**
-   * @brief A discrete Poisson random number distribution.
-   *
-   * The formula for the Poisson probability mass function is
-   * @f$ p(i) = \frac{mean^i}{i!} e^{-mean} @f$ where @f$ mean @f$ is the
-   * parameter of the distribution.
-   */
-  template<typename _IntType = int, typename _RealType = double>
-    class poisson_distribution
-    {
-    public:
-      // types
-      typedef _RealType input_type;
-      typedef _IntType  result_type;
-
-      // constructors and member function
-      explicit
-      poisson_distribution(const _RealType& __mean = _RealType(1))
-      : _M_mean(__mean), _M_nd()
-      {
-	_GLIBCXX_DEBUG_ASSERT(_M_mean > 0.0);
-	_M_initialize();
-      }
-
-      /**
-       * Gets the distribution parameter @p mean.
-       */
-      _RealType
-      mean() const
-      { return _M_mean; }
-
-      void
-      reset()
-      { _M_nd.reset(); }
-
-      template<class _UniformRandomNumberGenerator>
-        result_type
-        operator()(_UniformRandomNumberGenerator& __urng);
-
-      /**
-       * Inserts a %poisson_distribution random number distribution
-       * @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %poisson_distribution random number distribution.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _IntType1, typename _RealType1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const poisson_distribution<_IntType1, _RealType1>& __x);
-
-      /**
-       * Extracts a %poisson_distribution random number distribution
-       * @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A %poisson_distribution random number generator engine.
-       *
-       * @returns The input stream with @p __x extracted or in an error state.
-       */
-      template<typename _IntType1, typename _RealType1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   poisson_distribution<_IntType1, _RealType1>& __x);
-
-    private:
-      void
-      _M_initialize();
-
-      // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
-      normal_distribution<_RealType> _M_nd;
-
-      _RealType _M_mean;
-
-      // Hosts either log(mean) or the threshold of the simple method.
-      _RealType _M_lm_thr;
-#if _GLIBCXX_USE_C99_MATH_TR1
-      _RealType _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
-#endif
-    };
-
-
-  /**
-   * @brief A discrete binomial random number distribution.
-   *
-   * The formula for the binomial probability mass function is 
-   * @f$ p(i) = \binom{n}{i} p^i (1 - p)^{t - i} @f$ where @f$ t @f$
-   * and @f$ p @f$ are the parameters of the distribution.
-   */
-  template<typename _IntType = int, typename _RealType = double>
-    class binomial_distribution
-    {
-    public:
-      // types
-      typedef _RealType input_type;
-      typedef _IntType  result_type;
-
-      // constructors and member function
-      explicit
-      binomial_distribution(_IntType __t = 1,
-			    const _RealType& __p = _RealType(0.5))
-      : _M_t(__t), _M_p(__p), _M_nd()
-      {
-	_GLIBCXX_DEBUG_ASSERT((_M_t >= 0) && (_M_p >= 0.0) && (_M_p <= 1.0));
-	_M_initialize();
-      }
-
-      /**
-       * Gets the distribution @p t parameter.
-       */
-      _IntType
-      t() const
-      { return _M_t; }
-      
-      /**
-       * Gets the distribution @p p parameter.
-       */
-      _RealType
-      p() const
-      { return _M_p; }
-
-      void
-      reset()
-      { _M_nd.reset(); }
-
-      template<class _UniformRandomNumberGenerator>
-        result_type
-        operator()(_UniformRandomNumberGenerator& __urng);
-
-      /**
-       * Inserts a %binomial_distribution random number distribution
-       * @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %binomial_distribution random number distribution.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _IntType1, typename _RealType1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const binomial_distribution<_IntType1, _RealType1>& __x);
-
-      /**
-       * Extracts a %binomial_distribution random number distribution
-       * @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A %binomial_distribution random number generator engine.
-       *
-       * @returns The input stream with @p __x extracted or in an error state.
-       */
-      template<typename _IntType1, typename _RealType1,
-	       typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   binomial_distribution<_IntType1, _RealType1>& __x);
-
-    private:
-      void
-      _M_initialize();
-
-      template<class _UniformRandomNumberGenerator>
-        result_type
-        _M_waiting(_UniformRandomNumberGenerator& __urng, _IntType __t);
-
-      // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
-      normal_distribution<_RealType> _M_nd;
-
-      _RealType _M_q;
-#if _GLIBCXX_USE_C99_MATH_TR1
-      _RealType _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
-	        _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
-#endif
-      _RealType _M_p;
-      _IntType  _M_t;
-
-      bool      _M_easy;
-    };
-
-  /* @} */ // group tr1_random_distributions_discrete
-
-  /**
-   * @defgroup tr1_random_distributions_continuous Continuous Distributions
-   * @ingroup tr1_random_distributions
-   * @{
-   */
-
-  /**
-   * @brief Uniform continuous distribution for random numbers.
-   *
-   * A continuous random distribution on the range [min, max) with equal
-   * probability throughout the range.  The URNG should be real-valued and
-   * deliver number in the range [0, 1).
-   */
-  template<typename _RealType = double>
-    class uniform_real
-    {
-    public:
-      // types
-      typedef _RealType input_type;
-      typedef _RealType result_type;
-
-    public:
-      /**
-       * Constructs a uniform_real object.
-       *
-       * @param __min [IN]  The lower bound of the distribution.
-       * @param __max [IN]  The upper bound of the distribution.
-       */
-      explicit
-      uniform_real(_RealType __min = _RealType(0),
-		   _RealType __max = _RealType(1))
-      : _M_min(__min), _M_max(__max)
-      {
-	_GLIBCXX_DEBUG_ASSERT(_M_min <= _M_max);
-      }
-
-      result_type
-      min() const
-      { return _M_min; }
-
-      result_type
-      max() const
-      { return _M_max; }
-
-      void
-      reset() { }
-
-      template<class _UniformRandomNumberGenerator>
-        result_type
-        operator()(_UniformRandomNumberGenerator& __urng)
-        { return (__urng() * (_M_max - _M_min)) + _M_min; }
-
-      /**
-       * Inserts a %uniform_real random number distribution @p __x into the
-       * output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %uniform_real random number distribution.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _RealType1, typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const uniform_real<_RealType1>& __x);
-
-      /**
-       * Extracts a %uniform_real random number distribution
-       * @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A %uniform_real random number generator engine.
-       *
-       * @returns The input stream with @p __x extracted or in an error state.
-       */
-      template<typename _RealType1, typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   uniform_real<_RealType1>& __x);
-
-    private:
-      _RealType _M_min;
-      _RealType _M_max;
-    };
-
-
-  /**
-   * @brief An exponential continuous distribution for random numbers.
-   *
-   * The formula for the exponential probability mass function is 
-   * @f$ p(x) = \lambda e^{-\lambda x} @f$.
-   *
-   * <table border=1 cellpadding=10 cellspacing=0>
-   * <caption align=top>Distribution Statistics</caption>
-   * <tr><td>Mean</td><td>@f$ \frac{1}{\lambda} @f$</td></tr>
-   * <tr><td>Median</td><td>@f$ \frac{\ln 2}{\lambda} @f$</td></tr>
-   * <tr><td>Mode</td><td>@f$ zero @f$</td></tr>
-   * <tr><td>Range</td><td>@f$[0, \infty]@f$</td></tr>
-   * <tr><td>Standard Deviation</td><td>@f$ \frac{1}{\lambda} @f$</td></tr>
-   * </table>
-   */
-  template<typename _RealType = double>
-    class exponential_distribution
-    {
-    public:
-      // types
-      typedef _RealType input_type;
-      typedef _RealType result_type;
-
-    public:
-      /**
-       * Constructs an exponential distribution with inverse scale parameter
-       * @f$ \lambda @f$.
-       */
-      explicit
-      exponential_distribution(const result_type& __lambda = result_type(1))
-      : _M_lambda(__lambda)
-      { 
-	_GLIBCXX_DEBUG_ASSERT(_M_lambda > 0);
-      }
-
-      /**
-       * Gets the inverse scale parameter of the distribution.
-       */
-      _RealType
-      lambda() const
-      { return _M_lambda; }
-
-      /**
-       * Resets the distribution.
-       *
-       * Has no effect on exponential distributions.
-       */
-      void
-      reset() { }
-
-      template<class _UniformRandomNumberGenerator>
-        result_type
-        operator()(_UniformRandomNumberGenerator& __urng)
-        { return -std::log(__urng()) / _M_lambda; }
-
-      /**
-       * Inserts a %exponential_distribution random number distribution
-       * @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %exponential_distribution random number distribution.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _RealType1, typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const exponential_distribution<_RealType1>& __x);
-
-      /**
-       * Extracts a %exponential_distribution random number distribution
-       * @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x A %exponential_distribution random number
-       *            generator engine.
-       *
-       * @returns The input stream with @p __x extracted or in an error state.
-       */
-      template<typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   exponential_distribution& __x)
-        { return __is >> __x._M_lambda; }
-
-    private:
-      result_type _M_lambda;
-    };
-
-
-  /**
-   * @brief A normal continuous distribution for random numbers.
-   *
-   * The formula for the normal probability mass function is 
-   * @f$ p(x) = \frac{1}{\sigma \sqrt{2 \pi}} 
-   *            e^{- \frac{{x - mean}^ {2}}{2 \sigma ^ {2}} } @f$.
-   */
-  template<typename _RealType = double>
-    class normal_distribution
-    {
-    public:
-      // types
-      typedef _RealType input_type;
-      typedef _RealType result_type;
-
-    public:
-      /**
-       * Constructs a normal distribution with parameters @f$ mean @f$ and
-       * @f$ \sigma @f$.
-       */
-      explicit
-      normal_distribution(const result_type& __mean = result_type(0),
-			  const result_type& __sigma = result_type(1))
-      : _M_mean(__mean), _M_sigma(__sigma), _M_saved_available(false)
-      { 
-	_GLIBCXX_DEBUG_ASSERT(_M_sigma > 0);
-      }
-
-      /**
-       * Gets the mean of the distribution.
-       */
-      _RealType
-      mean() const
-      { return _M_mean; }
-
-      /**
-       * Gets the @f$ \sigma @f$ of the distribution.
-       */
-      _RealType
-      sigma() const
-      { return _M_sigma; }
-
-      /**
-       * Resets the distribution.
-       */
-      void
-      reset()
-      { _M_saved_available = false; }
-
-      template<class _UniformRandomNumberGenerator>
-        result_type
-        operator()(_UniformRandomNumberGenerator& __urng);
-
-      /**
-       * Inserts a %normal_distribution random number distribution
-       * @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %normal_distribution random number distribution.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _RealType1, typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const normal_distribution<_RealType1>& __x);
-
-      /**
-       * Extracts a %normal_distribution random number distribution
-       * @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A %normal_distribution random number generator engine.
-       *
-       * @returns The input stream with @p __x extracted or in an error state.
-       */
-      template<typename _RealType1, typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   normal_distribution<_RealType1>& __x);
-
-    private:
-      result_type _M_mean;
-      result_type _M_sigma;
-      result_type _M_saved;
-      bool        _M_saved_available;     
-    };
-
-
-  /**
-   * @brief A gamma continuous distribution for random numbers.
-   *
-   * The formula for the gamma probability mass function is 
-   * @f$ p(x) = \frac{1}{\Gamma(\alpha)} x^{\alpha - 1} e^{-x} @f$.
-   */
-  template<typename _RealType = double>
-    class gamma_distribution
-    {
-    public:
-      // types
-      typedef _RealType input_type;
-      typedef _RealType result_type;
-
-    public:
-      /**
-       * Constructs a gamma distribution with parameters @f$ \alpha @f$.
-       */
-      explicit
-      gamma_distribution(const result_type& __alpha_val = result_type(1))
-      : _M_alpha(__alpha_val)
-      { 
-	_GLIBCXX_DEBUG_ASSERT(_M_alpha > 0);
-	_M_initialize();
-      }
-
-      /**
-       * Gets the @f$ \alpha @f$ of the distribution.
-       */
-      _RealType
-      alpha() const
-      { return _M_alpha; }
-
-      /**
-       * Resets the distribution.
-       */
-      void
-      reset() { }
-
-      template<class _UniformRandomNumberGenerator>
-        result_type
-        operator()(_UniformRandomNumberGenerator& __urng);
-
-      /**
-       * Inserts a %gamma_distribution random number distribution
-       * @p __x into the output stream @p __os.
-       *
-       * @param __os An output stream.
-       * @param __x  A %gamma_distribution random number distribution.
-       *
-       * @returns The output stream with the state of @p __x inserted or in
-       * an error state.
-       */
-      template<typename _RealType1, typename _CharT, typename _Traits>
-        friend std::basic_ostream<_CharT, _Traits>&
-        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-		   const gamma_distribution<_RealType1>& __x);
-
-      /**
-       * Extracts a %gamma_distribution random number distribution
-       * @p __x from the input stream @p __is.
-       *
-       * @param __is An input stream.
-       * @param __x  A %gamma_distribution random number generator engine.
-       *
-       * @returns The input stream with @p __x extracted or in an error state.
-       */
-      template<typename _CharT, typename _Traits>
-        friend std::basic_istream<_CharT, _Traits>&
-        operator>>(std::basic_istream<_CharT, _Traits>& __is,
-		   gamma_distribution& __x)
-        {
-	  __is >> __x._M_alpha;
-	  __x._M_initialize();
-	  return __is;
-	}
-
-    private:
-      void
-      _M_initialize();
-
-      result_type _M_alpha;
-
-      // Hosts either lambda of GB or d of modified Vaduva's.
-      result_type _M_l_d;
-    };
-
-  /* @} */ // group tr1_random_distributions_continuous
-  /* @} */ // group tr1_random_distributions
-  /* @} */ // group tr1_random
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
-
-#include <tr1_impl/random.tcc>
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/random.tcc b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/random.tcc
deleted file mode 100644
index 4c78ce644..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/random.tcc
+++ /dev/null
@@ -1,1577 +0,0 @@
-// random number generation (out of line) -*- C++ -*-
-
-// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/random.tcc
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-  /*
-   * (Further) implementation-space details.
-   */
-  namespace __detail
-  {
-    // General case for x = (ax + c) mod m -- use Schrage's algorithm to avoid
-    // integer overflow.
-    //
-    // Because a and c are compile-time integral constants the compiler kindly
-    // elides any unreachable paths.
-    //
-    // Preconditions:  a > 0, m > 0.
-    //
-    template<typename _Tp, _Tp __a, _Tp __c, _Tp __m, bool>
-      struct _Mod
-      {
-	static _Tp
-	__calc(_Tp __x)
-	{
-	  if (__a == 1)
-	    __x %= __m;
-	  else
-	    {
-	      static const _Tp __q = __m / __a;
-	      static const _Tp __r = __m % __a;
-	      
-	      _Tp __t1 = __a * (__x % __q);
-	      _Tp __t2 = __r * (__x / __q);
-	      if (__t1 >= __t2)
-		__x = __t1 - __t2;
-	      else
-		__x = __m - __t2 + __t1;
-	    }
-
-	  if (__c != 0)
-	    {
-	      const _Tp __d = __m - __x;
-	      if (__d > __c)
-		__x += __c;
-	      else
-		__x = __c - __d;
-	    }
-	  return __x;
-	}
-      };
-
-    // Special case for m == 0 -- use unsigned integer overflow as modulo
-    // operator.
-    template<typename _Tp, _Tp __a, _Tp __c, _Tp __m>
-      struct _Mod<_Tp, __a, __c, __m, true>
-      {
-	static _Tp
-	__calc(_Tp __x)
-	{ return __a * __x + __c; }
-      };
-  } // namespace __detail
-
-  /**
-   * Seeds the LCR with integral value @p __x0, adjusted so that the 
-   * ring identity is never a member of the convergence set.
-   */
-  template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-    void
-    linear_congruential<_UIntType, __a, __c, __m>::
-    seed(unsigned long __x0)
-    {
-      if ((__detail::__mod<_UIntType, 1, 0, __m>(__c) == 0)
-	  && (__detail::__mod<_UIntType, 1, 0, __m>(__x0) == 0))
-	_M_x = __detail::__mod<_UIntType, 1, 0, __m>(1);
-      else
-	_M_x = __detail::__mod<_UIntType, 1, 0, __m>(__x0);
-    }
-
-  /**
-   * Seeds the LCR engine with a value generated by @p __g.
-   */
-  template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-    template<class _Gen>
-      void
-      linear_congruential<_UIntType, __a, __c, __m>::
-      seed(_Gen& __g, false_type)
-      {
-	_UIntType __x0 = __g();
-	if ((__detail::__mod<_UIntType, 1, 0, __m>(__c) == 0)
-	    && (__detail::__mod<_UIntType, 1, 0, __m>(__x0) == 0))
-	  _M_x = __detail::__mod<_UIntType, 1, 0, __m>(1);
-	else
-	  _M_x = __detail::__mod<_UIntType, 1, 0, __m>(__x0);
-      }
-
-  /**
-   * Gets the next generated value in sequence.
-   */
-  template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-    typename linear_congruential<_UIntType, __a, __c, __m>::result_type
-    linear_congruential<_UIntType, __a, __c, __m>::
-    operator()()
-    {
-      _M_x = __detail::__mod<_UIntType, __a, __c, __m>(_M_x);
-      return _M_x;
-    }
-
-  template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
-	   typename _CharT, typename _Traits>
-    std::basic_ostream<_CharT, _Traits>&
-    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-	       const linear_congruential<_UIntType, __a, __c, __m>& __lcr)
-    {
-      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
-      typedef typename __ostream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __os.flags();
-      const _CharT __fill = __os.fill();
-      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
-      __os.fill(__os.widen(' '));
-
-      __os << __lcr._M_x;
-
-      __os.flags(__flags);
-      __os.fill(__fill);
-      return __os;
-    }
-
-  template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
-	   typename _CharT, typename _Traits>
-    std::basic_istream<_CharT, _Traits>&
-    operator>>(std::basic_istream<_CharT, _Traits>& __is,
-	       linear_congruential<_UIntType, __a, __c, __m>& __lcr)
-    {
-      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
-      typedef typename __istream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __is.flags();
-      __is.flags(__ios_base::dec);
-
-      __is >> __lcr._M_x;
-
-      __is.flags(__flags);
-      return __is;
-    } 
-
-
-  template<class _UIntType, int __w, int __n, int __m, int __r,
-	   _UIntType __a, int __u, int __s,
-	   _UIntType __b, int __t, _UIntType __c, int __l>
-    void
-    mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
-		     __b, __t, __c, __l>::
-    seed(unsigned long __value)
-    {
-      _M_x[0] = __detail::__mod<_UIntType, 1, 0,
-	__detail::_Shift<_UIntType, __w>::__value>(__value);
-
-      for (int __i = 1; __i < state_size; ++__i)
-	{
-	  _UIntType __x = _M_x[__i - 1];
-	  __x ^= __x >> (__w - 2);
-	  __x *= 1812433253ul;
-	  __x += __i;
-	  _M_x[__i] = __detail::__mod<_UIntType, 1, 0,
-	    __detail::_Shift<_UIntType, __w>::__value>(__x);	  
-	}
-      _M_p = state_size;
-    }
-
-  template<class _UIntType, int __w, int __n, int __m, int __r,
-	   _UIntType __a, int __u, int __s,
-	   _UIntType __b, int __t, _UIntType __c, int __l>
-    template<class _Gen>
-      void
-      mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
-		       __b, __t, __c, __l>::
-      seed(_Gen& __gen, false_type)
-      {
-	for (int __i = 0; __i < state_size; ++__i)
-	  _M_x[__i] = __detail::__mod<_UIntType, 1, 0,
-	    __detail::_Shift<_UIntType, __w>::__value>(__gen());
-	_M_p = state_size;
-      }
-
-  template<class _UIntType, int __w, int __n, int __m, int __r,
-	   _UIntType __a, int __u, int __s,
-	   _UIntType __b, int __t, _UIntType __c, int __l>
-    typename
-    mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
-		     __b, __t, __c, __l>::result_type
-    mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
-		     __b, __t, __c, __l>::
-    operator()()
-    {
-      // Reload the vector - cost is O(n) amortized over n calls.
-      if (_M_p >= state_size)
-	{
-	  const _UIntType __upper_mask = (~_UIntType()) << __r;
-	  const _UIntType __lower_mask = ~__upper_mask;
-
-	  for (int __k = 0; __k < (__n - __m); ++__k)
-	    {
-	      _UIntType __y = ((_M_x[__k] & __upper_mask)
-			       | (_M_x[__k + 1] & __lower_mask));
-	      _M_x[__k] = (_M_x[__k + __m] ^ (__y >> 1)
-			   ^ ((__y & 0x01) ? __a : 0));
-	    }
-
-	  for (int __k = (__n - __m); __k < (__n - 1); ++__k)
-	    {
-	      _UIntType __y = ((_M_x[__k] & __upper_mask)
-			       | (_M_x[__k + 1] & __lower_mask));
-	      _M_x[__k] = (_M_x[__k + (__m - __n)] ^ (__y >> 1)
-			   ^ ((__y & 0x01) ? __a : 0));
-	    }
-
-	  _UIntType __y = ((_M_x[__n - 1] & __upper_mask)
-			   | (_M_x[0] & __lower_mask));
-	  _M_x[__n - 1] = (_M_x[__m - 1] ^ (__y >> 1)
-			   ^ ((__y & 0x01) ? __a : 0));
-	  _M_p = 0;
-	}
-
-      // Calculate o(x(i)).
-      result_type __z = _M_x[_M_p++];
-      __z ^= (__z >> __u);
-      __z ^= (__z << __s) & __b;
-      __z ^= (__z << __t) & __c;
-      __z ^= (__z >> __l);
-
-      return __z;
-    }
-
-  template<class _UIntType, int __w, int __n, int __m, int __r,
-	   _UIntType __a, int __u, int __s, _UIntType __b, int __t,
-	   _UIntType __c, int __l,
-	   typename _CharT, typename _Traits>
-    std::basic_ostream<_CharT, _Traits>&
-    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-	       const mersenne_twister<_UIntType, __w, __n, __m,
-	       __r, __a, __u, __s, __b, __t, __c, __l>& __x)
-    {
-      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
-      typedef typename __ostream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __os.flags();
-      const _CharT __fill = __os.fill();
-      const _CharT __space = __os.widen(' ');
-      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
-      __os.fill(__space);
-
-      for (int __i = 0; __i < __n - 1; ++__i)
-	__os << __x._M_x[__i] << __space;
-      __os << __x._M_x[__n - 1];
-
-      __os.flags(__flags);
-      __os.fill(__fill);
-      return __os;
-    }
-
-  template<class _UIntType, int __w, int __n, int __m, int __r,
-	   _UIntType __a, int __u, int __s, _UIntType __b, int __t,
-	   _UIntType __c, int __l,
-	   typename _CharT, typename _Traits>
-    std::basic_istream<_CharT, _Traits>&
-    operator>>(std::basic_istream<_CharT, _Traits>& __is,
-	       mersenne_twister<_UIntType, __w, __n, __m,
-	       __r, __a, __u, __s, __b, __t, __c, __l>& __x)
-    {
-      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
-      typedef typename __istream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __is.flags();
-      __is.flags(__ios_base::dec | __ios_base::skipws);
-
-      for (int __i = 0; __i < __n; ++__i)
-	__is >> __x._M_x[__i];
-
-      __is.flags(__flags);
-      return __is;
-    }
-
-
-  template<typename _IntType, _IntType __m, int __s, int __r>
-    void
-    subtract_with_carry<_IntType, __m, __s, __r>::
-    seed(unsigned long __value)
-    {
-      if (__value == 0)
-	__value = 19780503;
-
-      std::_GLIBCXX_TR1 linear_congruential<unsigned long, 40014, 0, 2147483563>
-	__lcg(__value);
-
-      for (int __i = 0; __i < long_lag; ++__i)
-	_M_x[__i] = __detail::__mod<_UIntType, 1, 0, modulus>(__lcg());
-
-      _M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0;
-      _M_p = 0;
-    }
-
-  template<typename _IntType, _IntType __m, int __s, int __r>
-    template<class _Gen>
-      void
-      subtract_with_carry<_IntType, __m, __s, __r>::
-      seed(_Gen& __gen, false_type)
-      {
-	const int __n = (std::numeric_limits<_UIntType>::digits + 31) / 32;
-
-	for (int __i = 0; __i < long_lag; ++__i)
-	  {
-	    _UIntType __tmp = 0;
-	    _UIntType __factor = 1;
-	    for (int __j = 0; __j < __n; ++__j)
-	      {
-		__tmp += __detail::__mod<__detail::_UInt32Type, 1, 0, 0>
-		         (__gen()) * __factor;
-		__factor *= __detail::_Shift<_UIntType, 32>::__value;
-	      }
-	    _M_x[__i] = __detail::__mod<_UIntType, 1, 0, modulus>(__tmp);
-	  }
-	_M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0;
-	_M_p = 0;
-      }
-
-  template<typename _IntType, _IntType __m, int __s, int __r>
-    typename subtract_with_carry<_IntType, __m, __s, __r>::result_type
-    subtract_with_carry<_IntType, __m, __s, __r>::
-    operator()()
-    {
-      // Derive short lag index from current index.
-      int __ps = _M_p - short_lag;
-      if (__ps < 0)
-	__ps += long_lag;
-
-      // Calculate new x(i) without overflow or division.
-      // NB: Thanks to the requirements for _IntType, _M_x[_M_p] + _M_carry
-      // cannot overflow.
-      _UIntType __xi;
-      if (_M_x[__ps] >= _M_x[_M_p] + _M_carry)
-	{
-	  __xi = _M_x[__ps] - _M_x[_M_p] - _M_carry;
-	  _M_carry = 0;
-	}
-      else
-	{
-	  __xi = modulus - _M_x[_M_p] - _M_carry + _M_x[__ps];
-	  _M_carry = 1;
-	}
-      _M_x[_M_p] = __xi;
-
-      // Adjust current index to loop around in ring buffer.
-      if (++_M_p >= long_lag)
-	_M_p = 0;
-
-      return __xi;
-    }
-
-  template<typename _IntType, _IntType __m, int __s, int __r,
-	   typename _CharT, typename _Traits>
-    std::basic_ostream<_CharT, _Traits>&
-    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-	       const subtract_with_carry<_IntType, __m, __s, __r>& __x)
-    {
-      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
-      typedef typename __ostream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __os.flags();
-      const _CharT __fill = __os.fill();
-      const _CharT __space = __os.widen(' ');
-      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
-      __os.fill(__space);
-
-      for (int __i = 0; __i < __r; ++__i)
-	__os << __x._M_x[__i] << __space;
-      __os << __x._M_carry;
-
-      __os.flags(__flags);
-      __os.fill(__fill);
-      return __os;
-    }
-
-  template<typename _IntType, _IntType __m, int __s, int __r,
-	   typename _CharT, typename _Traits>
-    std::basic_istream<_CharT, _Traits>&
-    operator>>(std::basic_istream<_CharT, _Traits>& __is,
-	       subtract_with_carry<_IntType, __m, __s, __r>& __x)
-    {
-      typedef std::basic_ostream<_CharT, _Traits>  __istream_type;
-      typedef typename __istream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __is.flags();
-      __is.flags(__ios_base::dec | __ios_base::skipws);
-
-      for (int __i = 0; __i < __r; ++__i)
-	__is >> __x._M_x[__i];
-      __is >> __x._M_carry;
-
-      __is.flags(__flags);
-      return __is;
-    }
-
-
-  template<typename _RealType, int __w, int __s, int __r>
-    void
-    subtract_with_carry_01<_RealType, __w, __s, __r>::
-    _M_initialize_npows()
-    {
-      for (int __j = 0; __j < __n; ++__j)
-#if _GLIBCXX_USE_C99_MATH_TR1
-	_M_npows[__j] = std::_GLIBCXX_TR1 ldexp(_RealType(1), -__w + __j * 32);
-#else
-        _M_npows[__j] = std::pow(_RealType(2), -__w + __j * 32);
-#endif
-    }
-
-  template<typename _RealType, int __w, int __s, int __r>
-    void
-    subtract_with_carry_01<_RealType, __w, __s, __r>::
-    seed(unsigned long __value)
-    {
-      if (__value == 0)
-	__value = 19780503;
-
-      // _GLIBCXX_RESOLVE_LIB_DEFECTS
-      // 512. Seeding subtract_with_carry_01 from a single unsigned long.
-      std::_GLIBCXX_TR1 linear_congruential<unsigned long, 40014, 0, 2147483563>
-	__lcg(__value);
-
-      this->seed(__lcg);
-    }
-
-  template<typename _RealType, int __w, int __s, int __r>
-    template<class _Gen>
-      void
-      subtract_with_carry_01<_RealType, __w, __s, __r>::
-      seed(_Gen& __gen, false_type)
-      {
-	for (int __i = 0; __i < long_lag; ++__i)
-	  {
-	    for (int __j = 0; __j < __n - 1; ++__j)
-	      _M_x[__i][__j] = __detail::__mod<_UInt32Type, 1, 0, 0>(__gen());
-	    _M_x[__i][__n - 1] = __detail::__mod<_UInt32Type, 1, 0,
-	      __detail::_Shift<_UInt32Type, __w % 32>::__value>(__gen());
-	  }
-
-	_M_carry = 1;
-	for (int __j = 0; __j < __n; ++__j)
-	  if (_M_x[long_lag - 1][__j] != 0)
-	    {
-	      _M_carry = 0;
-	      break;
-	    }
-
-	_M_p = 0;
-      }
-
-  template<typename _RealType, int __w, int __s, int __r>
-    typename subtract_with_carry_01<_RealType, __w, __s, __r>::result_type
-    subtract_with_carry_01<_RealType, __w, __s, __r>::
-    operator()()
-    {
-      // Derive short lag index from current index.
-      int __ps = _M_p - short_lag;
-      if (__ps < 0)
-	__ps += long_lag;
-
-      _UInt32Type __new_carry;
-      for (int __j = 0; __j < __n - 1; ++__j)
-	{
-	  if (_M_x[__ps][__j] > _M_x[_M_p][__j]
-	      || (_M_x[__ps][__j] == _M_x[_M_p][__j] && _M_carry == 0))
-	    __new_carry = 0;
-	  else
-	    __new_carry = 1;
-
-	  _M_x[_M_p][__j] = _M_x[__ps][__j] - _M_x[_M_p][__j] - _M_carry;
-	  _M_carry = __new_carry;
-	}
-
-      if (_M_x[__ps][__n - 1] > _M_x[_M_p][__n - 1]
-	  || (_M_x[__ps][__n - 1] == _M_x[_M_p][__n - 1] && _M_carry == 0))
-	__new_carry = 0;
-      else
-	__new_carry = 1;
-      
-      _M_x[_M_p][__n - 1] = __detail::__mod<_UInt32Type, 1, 0,
-	__detail::_Shift<_UInt32Type, __w % 32>::__value>
-	(_M_x[__ps][__n - 1] - _M_x[_M_p][__n - 1] - _M_carry);
-      _M_carry = __new_carry;
-
-      result_type __ret = 0.0;
-      for (int __j = 0; __j < __n; ++__j)
-	__ret += _M_x[_M_p][__j] * _M_npows[__j];
-
-      // Adjust current index to loop around in ring buffer.
-      if (++_M_p >= long_lag)
-	_M_p = 0;
-
-      return __ret;
-    }
-
-  template<typename _RealType, int __w, int __s, int __r,
-	   typename _CharT, typename _Traits>
-    std::basic_ostream<_CharT, _Traits>&
-    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-	       const subtract_with_carry_01<_RealType, __w, __s, __r>& __x)
-    {
-      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
-      typedef typename __ostream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __os.flags();
-      const _CharT __fill = __os.fill();
-      const _CharT __space = __os.widen(' ');
-      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
-      __os.fill(__space);
-
-      for (int __i = 0; __i < __r; ++__i)
-	for (int __j = 0; __j < __x.__n; ++__j)
-	  __os << __x._M_x[__i][__j] << __space;
-      __os << __x._M_carry;
-
-      __os.flags(__flags);
-      __os.fill(__fill);
-      return __os;
-    }
-
-  template<typename _RealType, int __w, int __s, int __r,
-	   typename _CharT, typename _Traits>
-    std::basic_istream<_CharT, _Traits>&
-    operator>>(std::basic_istream<_CharT, _Traits>& __is,
-	       subtract_with_carry_01<_RealType, __w, __s, __r>& __x)
-    {
-      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
-      typedef typename __istream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __is.flags();
-      __is.flags(__ios_base::dec | __ios_base::skipws);
-
-      for (int __i = 0; __i < __r; ++__i)
-	for (int __j = 0; __j < __x.__n; ++__j)
-	  __is >> __x._M_x[__i][__j];
-      __is >> __x._M_carry;
-
-      __is.flags(__flags);
-      return __is;
-    }
-
-
-  template<class _UniformRandomNumberGenerator, int __p, int __r>
-    typename discard_block<_UniformRandomNumberGenerator,
-			   __p, __r>::result_type
-    discard_block<_UniformRandomNumberGenerator, __p, __r>::
-    operator()()
-    {
-      if (_M_n >= used_block)
-	{
-	  while (_M_n < block_size)
-	    {
-	      _M_b();
-	      ++_M_n;
-	    }
-	  _M_n = 0;
-	}
-      ++_M_n;
-      return _M_b();
-    }
-
-  template<class _UniformRandomNumberGenerator, int __p, int __r,
-	   typename _CharT, typename _Traits>
-    std::basic_ostream<_CharT, _Traits>&
-    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-	       const discard_block<_UniformRandomNumberGenerator,
-	       __p, __r>& __x)
-    {
-      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
-      typedef typename __ostream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __os.flags();
-      const _CharT __fill = __os.fill();
-      const _CharT __space = __os.widen(' ');
-      __os.flags(__ios_base::dec | __ios_base::fixed
-		 | __ios_base::left);
-      __os.fill(__space);
-
-      __os << __x._M_b << __space << __x._M_n;
-
-      __os.flags(__flags);
-      __os.fill(__fill);
-      return __os;
-    }
-
-  template<class _UniformRandomNumberGenerator, int __p, int __r,
-	   typename _CharT, typename _Traits>
-    std::basic_istream<_CharT, _Traits>&
-    operator>>(std::basic_istream<_CharT, _Traits>& __is,
-	       discard_block<_UniformRandomNumberGenerator, __p, __r>& __x)
-    {
-      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
-      typedef typename __istream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __is.flags();
-      __is.flags(__ios_base::dec | __ios_base::skipws);
-
-      __is >> __x._M_b >> __x._M_n;
-
-      __is.flags(__flags);
-      return __is;
-    }
-
-
-  template<class _UniformRandomNumberGenerator1, int __s1,
-	   class _UniformRandomNumberGenerator2, int __s2>
-    void
-    xor_combine<_UniformRandomNumberGenerator1, __s1,
-		_UniformRandomNumberGenerator2, __s2>::
-    _M_initialize_max()
-    {
-      const int __w = std::numeric_limits<result_type>::digits;
-
-      const result_type __m1 =
-	std::min(result_type(_M_b1.max() - _M_b1.min()),
-		 __detail::_Shift<result_type, __w - __s1>::__value - 1);
-
-      const result_type __m2 =
-	std::min(result_type(_M_b2.max() - _M_b2.min()),
-		 __detail::_Shift<result_type, __w - __s2>::__value - 1);
-
-      // NB: In TR1 s1 is not required to be >= s2.
-      if (__s1 < __s2)
-	_M_max = _M_initialize_max_aux(__m2, __m1, __s2 - __s1) << __s1;
-      else
-	_M_max = _M_initialize_max_aux(__m1, __m2, __s1 - __s2) << __s2;
-    }
-
-  template<class _UniformRandomNumberGenerator1, int __s1,
-	   class _UniformRandomNumberGenerator2, int __s2>
-    typename xor_combine<_UniformRandomNumberGenerator1, __s1,
-			 _UniformRandomNumberGenerator2, __s2>::result_type
-    xor_combine<_UniformRandomNumberGenerator1, __s1,
-		_UniformRandomNumberGenerator2, __s2>::
-    _M_initialize_max_aux(result_type __a, result_type __b, int __d)
-    {
-      const result_type __two2d = result_type(1) << __d;
-      const result_type __c = __a * __two2d;
-
-      if (__a == 0 || __b < __two2d)
-	return __c + __b;
-
-      const result_type __t = std::max(__c, __b);
-      const result_type __u = std::min(__c, __b);
-
-      result_type __ub = __u;
-      result_type __p;
-      for (__p = 0; __ub != 1; __ub >>= 1)
-	++__p;
-
-      const result_type __two2p = result_type(1) << __p;
-      const result_type __k = __t / __two2p;
-
-      if (__k & 1)
-	return (__k + 1) * __two2p - 1;
-
-      if (__c >= __b)
-	return (__k + 1) * __two2p + _M_initialize_max_aux((__t % __two2p)
-							   / __two2d,
-							   __u % __two2p, __d);
-      else
-	return (__k + 1) * __two2p + _M_initialize_max_aux((__u % __two2p)
-							   / __two2d,
-							   __t % __two2p, __d);
-    }
-
-  template<class _UniformRandomNumberGenerator1, int __s1,
-	   class _UniformRandomNumberGenerator2, int __s2,
-	   typename _CharT, typename _Traits>
-    std::basic_ostream<_CharT, _Traits>&
-    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-	       const xor_combine<_UniformRandomNumberGenerator1, __s1,
-	       _UniformRandomNumberGenerator2, __s2>& __x)
-    {
-      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
-      typedef typename __ostream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __os.flags();
-      const _CharT __fill = __os.fill();
-      const _CharT __space = __os.widen(' ');
-      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
-      __os.fill(__space);
-
-      __os << __x.base1() << __space << __x.base2();
-
-      __os.flags(__flags);
-      __os.fill(__fill);
-      return __os; 
-    }
-
-  template<class _UniformRandomNumberGenerator1, int __s1,
-	   class _UniformRandomNumberGenerator2, int __s2,
-	   typename _CharT, typename _Traits>
-    std::basic_istream<_CharT, _Traits>&
-    operator>>(std::basic_istream<_CharT, _Traits>& __is,
-	       xor_combine<_UniformRandomNumberGenerator1, __s1,
-	       _UniformRandomNumberGenerator2, __s2>& __x)
-    {
-      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
-      typedef typename __istream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __is.flags();
-      __is.flags(__ios_base::skipws);
-
-      __is >> __x._M_b1 >> __x._M_b2;
-
-      __is.flags(__flags);
-      return __is;
-    }
-
-
-  template<typename _IntType>
-    template<typename _UniformRandomNumberGenerator>
-      typename uniform_int<_IntType>::result_type
-      uniform_int<_IntType>::
-      _M_call(_UniformRandomNumberGenerator& __urng,
-	      result_type __min, result_type __max, true_type)
-      {
-	// XXX Must be fixed to work well for *arbitrary* __urng.max(),
-	// __urng.min(), __max, __min.  Currently works fine only in the
-	// most common case __urng.max() - __urng.min() >= __max - __min,
-	// with __urng.max() > __urng.min() >= 0.
-	typedef typename __gnu_cxx::__add_unsigned<typename
-	  _UniformRandomNumberGenerator::result_type>::__type __urntype;
-	typedef typename __gnu_cxx::__add_unsigned<result_type>::__type
-	                                                      __utype;
-	typedef typename __gnu_cxx::__conditional_type<(sizeof(__urntype)
-							> sizeof(__utype)),
-	  __urntype, __utype>::__type                         __uctype;
-
-	result_type __ret;
-
-	const __urntype __urnmin = __urng.min();
-	const __urntype __urnmax = __urng.max();
-	const __urntype __urnrange = __urnmax - __urnmin;
-	const __uctype __urange = __max - __min;
-	const __uctype __udenom = (__urnrange <= __urange
-				   ? 1 : __urnrange / (__urange + 1));
-	do
-	  __ret = (__urntype(__urng()) -  __urnmin) / __udenom;
-	while (__ret > __max - __min);
-
-	return __ret + __min;
-      }
-
-  template<typename _IntType, typename _CharT, typename _Traits>
-    std::basic_ostream<_CharT, _Traits>&
-    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-	       const uniform_int<_IntType>& __x)
-    {
-      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
-      typedef typename __ostream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __os.flags();
-      const _CharT __fill = __os.fill();
-      const _CharT __space = __os.widen(' ');
-      __os.flags(__ios_base::scientific | __ios_base::left);
-      __os.fill(__space);
-
-      __os << __x.min() << __space << __x.max();
-
-      __os.flags(__flags);
-      __os.fill(__fill);
-      return __os;
-    }
-
-  template<typename _IntType, typename _CharT, typename _Traits>
-    std::basic_istream<_CharT, _Traits>&
-    operator>>(std::basic_istream<_CharT, _Traits>& __is,
-	       uniform_int<_IntType>& __x)
-    {
-      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
-      typedef typename __istream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __is.flags();
-      __is.flags(__ios_base::dec | __ios_base::skipws);
-
-      __is >> __x._M_min >> __x._M_max;
-
-      __is.flags(__flags);
-      return __is;
-    }
-
-  
-  template<typename _CharT, typename _Traits>
-    std::basic_ostream<_CharT, _Traits>&
-    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-	       const bernoulli_distribution& __x)
-    {
-      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
-      typedef typename __ostream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __os.flags();
-      const _CharT __fill = __os.fill();
-      const std::streamsize __precision = __os.precision();
-      __os.flags(__ios_base::scientific | __ios_base::left);
-      __os.fill(__os.widen(' '));
-      __os.precision(__gnu_cxx::__numeric_traits<double>::__max_digits10);
-
-      __os << __x.p();
-
-      __os.flags(__flags);
-      __os.fill(__fill);
-      __os.precision(__precision);
-      return __os;
-    }
-
-
-  template<typename _IntType, typename _RealType>
-    template<class _UniformRandomNumberGenerator>
-      typename geometric_distribution<_IntType, _RealType>::result_type
-      geometric_distribution<_IntType, _RealType>::
-      operator()(_UniformRandomNumberGenerator& __urng)
-      {
-	// About the epsilon thing see this thread:
-        // http://gcc.gnu.org/ml/gcc-patches/2006-10/msg00971.html
-	const _RealType __naf =
-	  (1 - std::numeric_limits<_RealType>::epsilon()) / 2;
-	// The largest _RealType convertible to _IntType.
-	const _RealType __thr =
-	  std::numeric_limits<_IntType>::max() + __naf;
-
-	_RealType __cand;
-	do
-	  __cand = std::ceil(std::log(__urng()) / _M_log_p);
-	while (__cand >= __thr);
-
-	return result_type(__cand + __naf);
-      }
-
-  template<typename _IntType, typename _RealType,
-	   typename _CharT, typename _Traits>
-    std::basic_ostream<_CharT, _Traits>&
-    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-	       const geometric_distribution<_IntType, _RealType>& __x)
-    {
-      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
-      typedef typename __ostream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __os.flags();
-      const _CharT __fill = __os.fill();
-      const std::streamsize __precision = __os.precision();
-      __os.flags(__ios_base::scientific | __ios_base::left);
-      __os.fill(__os.widen(' '));
-      __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10);
-
-      __os << __x.p();
-
-      __os.flags(__flags);
-      __os.fill(__fill);
-      __os.precision(__precision);
-      return __os;
-    }
-
-
-  template<typename _IntType, typename _RealType>
-    void
-    poisson_distribution<_IntType, _RealType>::
-    _M_initialize()
-    {
-#if _GLIBCXX_USE_C99_MATH_TR1
-      if (_M_mean >= 12)
-	{
-	  const _RealType __m = std::floor(_M_mean);
-	  _M_lm_thr = std::log(_M_mean);
-	  _M_lfm = std::_GLIBCXX_TR1 lgamma(__m + 1);
-	  _M_sm = std::sqrt(__m);
-
-	  const _RealType __pi_4 = 0.7853981633974483096156608458198757L;
-	  const _RealType __dx = std::sqrt(2 * __m * std::log(32 * __m
-							      / __pi_4));
-	  _M_d = std::_GLIBCXX_TR1 round(std::max(_RealType(6),
-						  std::min(__m, __dx)));
-	  const _RealType __cx = 2 * __m + _M_d;
-	  _M_scx = std::sqrt(__cx / 2);
-	  _M_1cx = 1 / __cx;
-
-	  _M_c2b = std::sqrt(__pi_4 * __cx) * std::exp(_M_1cx);
-	  _M_cb = 2 * __cx * std::exp(-_M_d * _M_1cx * (1 + _M_d / 2)) / _M_d;
-	}
-      else
-#endif
-	_M_lm_thr = std::exp(-_M_mean);
-      }
-
-  /**
-   * A rejection algorithm when mean >= 12 and a simple method based
-   * upon the multiplication of uniform random variates otherwise.
-   * NB: The former is available only if _GLIBCXX_USE_C99_MATH_TR1
-   * is defined.
-   *
-   * Reference:
-   * Devroye, L. "Non-Uniform Random Variates Generation." Springer-Verlag,
-   * New York, 1986, Ch. X, Sects. 3.3 & 3.4 (+ Errata!).
-   */
-  template<typename _IntType, typename _RealType>
-    template<class _UniformRandomNumberGenerator>
-      typename poisson_distribution<_IntType, _RealType>::result_type
-      poisson_distribution<_IntType, _RealType>::
-      operator()(_UniformRandomNumberGenerator& __urng)
-      {
-#if _GLIBCXX_USE_C99_MATH_TR1
-	if (_M_mean >= 12)
-	  {
-	    _RealType __x;
-
-	    // See comments above...
-	    const _RealType __naf =
-	      (1 - std::numeric_limits<_RealType>::epsilon()) / 2;
-	    const _RealType __thr =
-	      std::numeric_limits<_IntType>::max() + __naf;
-
-	    const _RealType __m = std::floor(_M_mean);
-	    // sqrt(pi / 2)
-	    const _RealType __spi_2 = 1.2533141373155002512078826424055226L;
-	    const _RealType __c1 = _M_sm * __spi_2;
-	    const _RealType __c2 = _M_c2b + __c1; 
-	    const _RealType __c3 = __c2 + 1;
-	    const _RealType __c4 = __c3 + 1;
-	    // e^(1 / 78)
-	    const _RealType __e178 = 1.0129030479320018583185514777512983L;
-	    const _RealType __c5 = __c4 + __e178;
-	    const _RealType __c = _M_cb + __c5;
-	    const _RealType __2cx = 2 * (2 * __m + _M_d);
-
-	    bool __reject = true;
-	    do
-	      {
-		const _RealType __u = __c * __urng();
-		const _RealType __e = -std::log(__urng());
-
-		_RealType __w = 0.0;
-		
-		if (__u <= __c1)
-		  {
-		    const _RealType __n = _M_nd(__urng);
-		    const _RealType __y = -std::abs(__n) * _M_sm - 1;
-		    __x = std::floor(__y);
-		    __w = -__n * __n / 2;
-		    if (__x < -__m)
-		      continue;
-		  }
-		else if (__u <= __c2)
-		  {
-		    const _RealType __n = _M_nd(__urng);
-		    const _RealType __y = 1 + std::abs(__n) * _M_scx;
-		    __x = std::ceil(__y);
-		    __w = __y * (2 - __y) * _M_1cx;
-		    if (__x > _M_d)
-		      continue;
-		  }
-		else if (__u <= __c3)
-		  // NB: This case not in the book, nor in the Errata,
-		  // but should be ok...
-		  __x = -1;
-		else if (__u <= __c4)
-		  __x = 0;
-		else if (__u <= __c5)
-		  __x = 1;
-		else
-		  {
-		    const _RealType __v = -std::log(__urng());
-		    const _RealType __y = _M_d + __v * __2cx / _M_d;
-		    __x = std::ceil(__y);
-		    __w = -_M_d * _M_1cx * (1 + __y / 2);
-		  }
-
-		__reject = (__w - __e - __x * _M_lm_thr
-			    > _M_lfm - std::_GLIBCXX_TR1 lgamma(__x + __m + 1));
-
-		__reject |= __x + __m >= __thr;
-
-	      } while (__reject);
-
-	    return result_type(__x + __m + __naf);
-	  }
-	else
-#endif
-	  {
-	    _IntType     __x = 0;
-	    _RealType __prod = 1.0;
-
-	    do
-	      {
-		__prod *= __urng();
-		__x += 1;
-	      }
-	    while (__prod > _M_lm_thr);
-
-	    return __x - 1;
-	  }
-      }
-
-  template<typename _IntType, typename _RealType,
-	   typename _CharT, typename _Traits>
-    std::basic_ostream<_CharT, _Traits>&
-    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-	       const poisson_distribution<_IntType, _RealType>& __x)
-    {
-      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
-      typedef typename __ostream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __os.flags();
-      const _CharT __fill = __os.fill();
-      const std::streamsize __precision = __os.precision();
-      const _CharT __space = __os.widen(' ');
-      __os.flags(__ios_base::scientific | __ios_base::left);
-      __os.fill(__space);
-      __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10);
-
-      __os << __x.mean() << __space << __x._M_nd;
-
-      __os.flags(__flags);
-      __os.fill(__fill);
-      __os.precision(__precision);
-      return __os;
-    }
-
-  template<typename _IntType, typename _RealType,
-	   typename _CharT, typename _Traits>
-    std::basic_istream<_CharT, _Traits>&
-    operator>>(std::basic_istream<_CharT, _Traits>& __is,
-	       poisson_distribution<_IntType, _RealType>& __x)
-    {
-      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
-      typedef typename __istream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __is.flags();
-      __is.flags(__ios_base::skipws);
-
-      __is >> __x._M_mean >> __x._M_nd;
-      __x._M_initialize();
-
-      __is.flags(__flags);
-      return __is;
-    }
-
-
-  template<typename _IntType, typename _RealType>
-    void
-    binomial_distribution<_IntType, _RealType>::
-    _M_initialize()
-    {
-      const _RealType __p12 = _M_p <= 0.5 ? _M_p : 1.0 - _M_p;
-
-      _M_easy = true;
-
-#if _GLIBCXX_USE_C99_MATH_TR1
-      if (_M_t * __p12 >= 8)
-	{
-	  _M_easy = false;
-	  const _RealType __np = std::floor(_M_t * __p12);
-	  const _RealType __pa = __np / _M_t;
-	  const _RealType __1p = 1 - __pa;
-	  
-	  const _RealType __pi_4 = 0.7853981633974483096156608458198757L;
-	  const _RealType __d1x =
-	    std::sqrt(__np * __1p * std::log(32 * __np
-					     / (81 * __pi_4 * __1p)));
-	  _M_d1 = std::_GLIBCXX_TR1 round(std::max(_RealType(1), __d1x));
-	  const _RealType __d2x =
-	    std::sqrt(__np * __1p * std::log(32 * _M_t * __1p
-					     / (__pi_4 * __pa)));
-	  _M_d2 = std::_GLIBCXX_TR1 round(std::max(_RealType(1), __d2x));
-	  
-	  // sqrt(pi / 2)
-	  const _RealType __spi_2 = 1.2533141373155002512078826424055226L;
-	  _M_s1 = std::sqrt(__np * __1p) * (1 + _M_d1 / (4 * __np));
-	  _M_s2 = std::sqrt(__np * __1p) * (1 + _M_d2 / (4 * _M_t * __1p));
-	  _M_c = 2 * _M_d1 / __np;
-	  _M_a1 = std::exp(_M_c) * _M_s1 * __spi_2;
-	  const _RealType __a12 = _M_a1 + _M_s2 * __spi_2;
-	  const _RealType __s1s = _M_s1 * _M_s1;
-	  _M_a123 = __a12 + (std::exp(_M_d1 / (_M_t * __1p))
-			     * 2 * __s1s / _M_d1
-			     * std::exp(-_M_d1 * _M_d1 / (2 * __s1s)));
-	  const _RealType __s2s = _M_s2 * _M_s2;
-	  _M_s = (_M_a123 + 2 * __s2s / _M_d2
-		  * std::exp(-_M_d2 * _M_d2 / (2 * __s2s)));
-	  _M_lf = (std::_GLIBCXX_TR1 lgamma(__np + 1)
-		   + std::_GLIBCXX_TR1 lgamma(_M_t - __np + 1));
-	  _M_lp1p = std::log(__pa / __1p);
-
-	  _M_q = -std::log(1 - (__p12 - __pa) / __1p);
-	}
-      else
-#endif
-	_M_q = -std::log(1 - __p12);
-    }
-
-  template<typename _IntType, typename _RealType>
-    template<class _UniformRandomNumberGenerator>
-      typename binomial_distribution<_IntType, _RealType>::result_type
-      binomial_distribution<_IntType, _RealType>::
-      _M_waiting(_UniformRandomNumberGenerator& __urng, _IntType __t)
-      {
-	_IntType    __x = 0;
-	_RealType __sum = 0;
-
-	do
-	  {
-	    const _RealType __e = -std::log(__urng());
-	    __sum += __e / (__t - __x);
-	    __x += 1;
-	  }
-	while (__sum <= _M_q);
-
-	return __x - 1;
-      }
-
-  /**
-   * A rejection algorithm when t * p >= 8 and a simple waiting time
-   * method - the second in the referenced book - otherwise.
-   * NB: The former is available only if _GLIBCXX_USE_C99_MATH_TR1
-   * is defined.
-   *
-   * Reference:
-   * Devroye, L. "Non-Uniform Random Variates Generation." Springer-Verlag,
-   * New York, 1986, Ch. X, Sect. 4 (+ Errata!).
-   */
-  template<typename _IntType, typename _RealType>
-    template<class _UniformRandomNumberGenerator>
-      typename binomial_distribution<_IntType, _RealType>::result_type
-      binomial_distribution<_IntType, _RealType>::
-      operator()(_UniformRandomNumberGenerator& __urng)
-      {
-	result_type __ret;
-	const _RealType __p12 = _M_p <= 0.5 ? _M_p : 1.0 - _M_p;
-
-#if _GLIBCXX_USE_C99_MATH_TR1
-	if (!_M_easy)
-	  {
-	    _RealType __x;
-
-	    // See comments above...
-	    const _RealType __naf =
-	      (1 - std::numeric_limits<_RealType>::epsilon()) / 2;
-	    const _RealType __thr =
-	      std::numeric_limits<_IntType>::max() + __naf;
-
-	    const _RealType __np = std::floor(_M_t * __p12);
-	    const _RealType __pa = __np / _M_t;
-
-	    // sqrt(pi / 2)
-	    const _RealType __spi_2 = 1.2533141373155002512078826424055226L;
-	    const _RealType __a1 = _M_a1;
-	    const _RealType __a12 = __a1 + _M_s2 * __spi_2;
-	    const _RealType __a123 = _M_a123;
-	    const _RealType __s1s = _M_s1 * _M_s1;
-	    const _RealType __s2s = _M_s2 * _M_s2;
-
-	    bool __reject;
-	    do
-	      {
-		const _RealType __u = _M_s * __urng();
-
-		_RealType __v;
-
-		if (__u <= __a1)
-		  {
-		    const _RealType __n = _M_nd(__urng);
-		    const _RealType __y = _M_s1 * std::abs(__n);
-		    __reject = __y >= _M_d1;
-		    if (!__reject)
-		      {
-			const _RealType __e = -std::log(__urng());
-			__x = std::floor(__y);
-			__v = -__e - __n * __n / 2 + _M_c;
-		      }
-		  }
-		else if (__u <= __a12)
-		  {
-		    const _RealType __n = _M_nd(__urng);
-		    const _RealType __y = _M_s2 * std::abs(__n);
-		    __reject = __y >= _M_d2;
-		    if (!__reject)
-		      {
-			const _RealType __e = -std::log(__urng());
-			__x = std::floor(-__y);
-			__v = -__e - __n * __n / 2;
-		      }
-		  }
-		else if (__u <= __a123)
-		  {
-		    const _RealType __e1 = -std::log(__urng());		    
-		    const _RealType __e2 = -std::log(__urng());
-
-		    const _RealType __y = _M_d1 + 2 * __s1s * __e1 / _M_d1;
-		    __x = std::floor(__y);
-		    __v = (-__e2 + _M_d1 * (1 / (_M_t - __np)
-					    -__y / (2 * __s1s)));
-		    __reject = false;
-		  }
-		else
-		  {
-		    const _RealType __e1 = -std::log(__urng());		    
-		    const _RealType __e2 = -std::log(__urng());
-
-		    const _RealType __y = _M_d2 + 2 * __s2s * __e1 / _M_d2;
-		    __x = std::floor(-__y);
-		    __v = -__e2 - _M_d2 * __y / (2 * __s2s);
-		    __reject = false;
-		  }
-
-		__reject = __reject || __x < -__np || __x > _M_t - __np;
-		if (!__reject)
-		  {
-		    const _RealType __lfx =
-		      std::_GLIBCXX_TR1 lgamma(__np + __x + 1)
-		      + std::_GLIBCXX_TR1 lgamma(_M_t - (__np + __x) + 1);
-		    __reject = __v > _M_lf - __lfx + __x * _M_lp1p;
-		  }
-
-		__reject |= __x + __np >= __thr;
-	      }
-	    while (__reject);
-
-	    __x += __np + __naf;
-
-	    const _IntType __z = _M_waiting(__urng, _M_t - _IntType(__x)); 
-	    __ret = _IntType(__x) + __z;
-	  }
-	else
-#endif
-	  __ret = _M_waiting(__urng, _M_t);
-
-	if (__p12 != _M_p)
-	  __ret = _M_t - __ret;
-	return __ret;
-      }
-
-  template<typename _IntType, typename _RealType,
-	   typename _CharT, typename _Traits>
-    std::basic_ostream<_CharT, _Traits>&
-    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-	       const binomial_distribution<_IntType, _RealType>& __x)
-    {
-      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
-      typedef typename __ostream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __os.flags();
-      const _CharT __fill = __os.fill();
-      const std::streamsize __precision = __os.precision();
-      const _CharT __space = __os.widen(' ');
-      __os.flags(__ios_base::scientific | __ios_base::left);
-      __os.fill(__space);
-      __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10);
-
-      __os << __x.t() << __space << __x.p() 
-	   << __space << __x._M_nd;
-
-      __os.flags(__flags);
-      __os.fill(__fill);
-      __os.precision(__precision);
-      return __os;
-    }
-
-  template<typename _IntType, typename _RealType,
-	   typename _CharT, typename _Traits>
-    std::basic_istream<_CharT, _Traits>&
-    operator>>(std::basic_istream<_CharT, _Traits>& __is,
-	       binomial_distribution<_IntType, _RealType>& __x)
-    {
-      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
-      typedef typename __istream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __is.flags();
-      __is.flags(__ios_base::dec | __ios_base::skipws);
-
-      __is >> __x._M_t >> __x._M_p >> __x._M_nd;
-      __x._M_initialize();
-
-      __is.flags(__flags);
-      return __is;
-    }
-
-
-  template<typename _RealType, typename _CharT, typename _Traits>
-    std::basic_ostream<_CharT, _Traits>&
-    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-	       const uniform_real<_RealType>& __x)
-    {
-      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
-      typedef typename __ostream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __os.flags();
-      const _CharT __fill = __os.fill();
-      const std::streamsize __precision = __os.precision();
-      const _CharT __space = __os.widen(' ');
-      __os.flags(__ios_base::scientific | __ios_base::left);
-      __os.fill(__space);
-      __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10);
-
-      __os << __x.min() << __space << __x.max();
-
-      __os.flags(__flags);
-      __os.fill(__fill);
-      __os.precision(__precision);
-      return __os;
-    }
-
-  template<typename _RealType, typename _CharT, typename _Traits>
-    std::basic_istream<_CharT, _Traits>&
-    operator>>(std::basic_istream<_CharT, _Traits>& __is,
-	       uniform_real<_RealType>& __x)
-    {
-      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
-      typedef typename __istream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __is.flags();
-      __is.flags(__ios_base::skipws);
-
-      __is >> __x._M_min >> __x._M_max;
-
-      __is.flags(__flags);
-      return __is;
-    }
-
-
-  template<typename _RealType, typename _CharT, typename _Traits>
-    std::basic_ostream<_CharT, _Traits>&
-    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-	       const exponential_distribution<_RealType>& __x)
-    {
-      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
-      typedef typename __ostream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __os.flags();
-      const _CharT __fill = __os.fill();
-      const std::streamsize __precision = __os.precision();
-      __os.flags(__ios_base::scientific | __ios_base::left);
-      __os.fill(__os.widen(' '));
-      __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10);
-
-      __os << __x.lambda();
-
-      __os.flags(__flags);
-      __os.fill(__fill);
-      __os.precision(__precision);
-      return __os;
-    }
-
-
-  /**
-   * Polar method due to Marsaglia.
-   *
-   * Devroye, L. "Non-Uniform Random Variates Generation." Springer-Verlag,
-   * New York, 1986, Ch. V, Sect. 4.4.
-   */
-  template<typename _RealType>
-    template<class _UniformRandomNumberGenerator>
-      typename normal_distribution<_RealType>::result_type
-      normal_distribution<_RealType>::
-      operator()(_UniformRandomNumberGenerator& __urng)
-      {
-	result_type __ret;
-
-	if (_M_saved_available)
-	  {
-	    _M_saved_available = false;
-	    __ret = _M_saved;
-	  }
-	else
-	  {
-	    result_type __x, __y, __r2;
-	    do
-	      {
-		__x = result_type(2.0) * __urng() - 1.0;
-		__y = result_type(2.0) * __urng() - 1.0;
-		__r2 = __x * __x + __y * __y;
-	      }
-	    while (__r2 > 1.0 || __r2 == 0.0);
-
-	    const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2);
-	    _M_saved = __x * __mult;
-	    _M_saved_available = true;
-	    __ret = __y * __mult;
-	  }
-	
-	__ret = __ret * _M_sigma + _M_mean;
-	return __ret;
-      }
-
-  template<typename _RealType, typename _CharT, typename _Traits>
-    std::basic_ostream<_CharT, _Traits>&
-    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-	       const normal_distribution<_RealType>& __x)
-    {
-      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
-      typedef typename __ostream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __os.flags();
-      const _CharT __fill = __os.fill();
-      const std::streamsize __precision = __os.precision();
-      const _CharT __space = __os.widen(' ');
-      __os.flags(__ios_base::scientific | __ios_base::left);
-      __os.fill(__space);
-      __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10);
-
-      __os << __x._M_saved_available << __space
-	   << __x.mean() << __space
-	   << __x.sigma();
-      if (__x._M_saved_available)
-	__os << __space << __x._M_saved;
-
-      __os.flags(__flags);
-      __os.fill(__fill);
-      __os.precision(__precision);
-      return __os;
-    }
-
-  template<typename _RealType, typename _CharT, typename _Traits>
-    std::basic_istream<_CharT, _Traits>&
-    operator>>(std::basic_istream<_CharT, _Traits>& __is,
-	       normal_distribution<_RealType>& __x)
-    {
-      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
-      typedef typename __istream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __is.flags();
-      __is.flags(__ios_base::dec | __ios_base::skipws);
-
-      __is >> __x._M_saved_available >> __x._M_mean
-	   >> __x._M_sigma;
-      if (__x._M_saved_available)
-	__is >> __x._M_saved;
-
-      __is.flags(__flags);
-      return __is;
-    }
-
-
-  template<typename _RealType>
-    void
-    gamma_distribution<_RealType>::
-    _M_initialize()
-    {
-      if (_M_alpha >= 1)
-	_M_l_d = std::sqrt(2 * _M_alpha - 1);
-      else
-	_M_l_d = (std::pow(_M_alpha, _M_alpha / (1 - _M_alpha))
-		  * (1 - _M_alpha));
-    }
-
-  /**
-   * Cheng's rejection algorithm GB for alpha >= 1 and a modification
-   * of Vaduva's rejection from Weibull algorithm due to Devroye for
-   * alpha < 1.
-   *
-   * References:
-   * Cheng, R. C. "The Generation of Gamma Random Variables with Non-integral
-   * Shape Parameter." Applied Statistics, 26, 71-75, 1977.
-   *
-   * Vaduva, I. "Computer Generation of Gamma Gandom Variables by Rejection
-   * and Composition Procedures." Math. Operationsforschung and Statistik,
-   * Series in Statistics, 8, 545-576, 1977.
-   *
-   * Devroye, L. "Non-Uniform Random Variates Generation." Springer-Verlag,
-   * New York, 1986, Ch. IX, Sect. 3.4 (+ Errata!).
-   */
-  template<typename _RealType>
-    template<class _UniformRandomNumberGenerator>
-      typename gamma_distribution<_RealType>::result_type
-      gamma_distribution<_RealType>::
-      operator()(_UniformRandomNumberGenerator& __urng)
-      {
-	result_type __x;
-
-	bool __reject;
-	if (_M_alpha >= 1)
-	  {
-	    // alpha - log(4)
-	    const result_type __b = _M_alpha
-	      - result_type(1.3862943611198906188344642429163531L);
-	    const result_type __c = _M_alpha + _M_l_d;
-	    const result_type __1l = 1 / _M_l_d;
-
-	    // 1 + log(9 / 2)
-	    const result_type __k = 2.5040773967762740733732583523868748L;
-
-	    do
-	      {
-		const result_type __u = __urng();
-		const result_type __v = __urng();
-
-		const result_type __y = __1l * std::log(__v / (1 - __v));
-		__x = _M_alpha * std::exp(__y);
-
-		const result_type __z = __u * __v * __v;
-		const result_type __r = __b + __c * __y - __x;
-
-		__reject = __r < result_type(4.5) * __z - __k;
-		if (__reject)
-		  __reject = __r < std::log(__z);
-	      }
-	    while (__reject);
-	  }
-	else
-	  {
-	    const result_type __c = 1 / _M_alpha;
-
-	    do
-	      {
-		const result_type __z = -std::log(__urng());
-		const result_type __e = -std::log(__urng());
-
-		__x = std::pow(__z, __c);
-
-		__reject = __z + __e < _M_l_d + __x;
-	      }
-	    while (__reject);
-	  }
-
-	return __x;
-      }
-
-  template<typename _RealType, typename _CharT, typename _Traits>
-    std::basic_ostream<_CharT, _Traits>&
-    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-	       const gamma_distribution<_RealType>& __x)
-    {
-      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
-      typedef typename __ostream_type::ios_base    __ios_base;
-
-      const typename __ios_base::fmtflags __flags = __os.flags();
-      const _CharT __fill = __os.fill();
-      const std::streamsize __precision = __os.precision();
-      __os.flags(__ios_base::scientific | __ios_base::left);
-      __os.fill(__os.widen(' '));
-      __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10);
-
-      __os << __x.alpha();
-
-      __os.flags(__flags);
-      __os.fill(__fill);
-      __os.precision(__precision);
-      return __os;
-    }
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/regex b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/regex
deleted file mode 100644
index 9352bc137..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/regex
+++ /dev/null
@@ -1,2708 +0,0 @@
-// class template regex -*- C++ -*-
-
-// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/**
- * @file tr1_impl/regex
- * @brief The common implementation file for tr1 and std regular expressions.
- *
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-/**
- * @defgroup tr1_regex Regular Expressions
- * A facility for performing regular expression pattern matching.
- */
- //@{
-
-/** @namespace std::regex_constants
- *  @brief ISO C++ 0x entities sub namespace for regex.
- */
-namespace regex_constants
-{
-  /**
-   * @name 5.1 Regular Expression Syntax Options
-   */
-  //@{
-  enum __syntax_option
-    {
-      _S_icase,
-      _S_nosubs,
-      _S_optimize,
-      _S_collate,
-      _S_ECMAScript,
-      _S_basic,
-      _S_extended,
-      _S_awk,
-      _S_grep,
-      _S_egrep,
-      _S_syntax_last
-    };
-
-  /**
-   * @brief This is a bitmask type indicating how to interpret the regex.
-   *
-   * The @c syntax_option_type is implementation defined but it is valid to
-   * perform bitwise operations on these values and expect the right thing to
-   * happen.
-   *
-   * A valid value of type syntax_option_type shall have exactly one of the
-   * elements @c ECMAScript, @c basic, @c extended, @c awk, @c grep, @c egrep
-   * %set.
-   */
-  typedef unsigned int syntax_option_type;
-
-  /** 
-   * Specifies that the matching of regular expressions against a character
-   * sequence shall be performed without regard to case.
-   */
-  static const syntax_option_type icase      = 1 << _S_icase;
-
-  /**
-   * Specifies that when a regular expression is matched against a character
-   * container sequence, no sub-expression matches are to be stored in the
-   * supplied match_results structure.
-   */
-  static const syntax_option_type nosubs     = 1 << _S_nosubs;
-
-  /**
-   * Specifies that the regular expression engine should pay more attention to
-   * the speed with which regular expressions are matched, and less to the
-   * speed with which regular expression objects are constructed. Otherwise
-   * it has no detectable effect on the program output.
-   */
-  static const syntax_option_type optimize   = 1 << _S_optimize;
-
-  /**
-   * Specifies that character ranges of the form [a-b] should be locale
-   * sensitive.
-   */
-  static const syntax_option_type collate    = 1 << _S_collate;
-
-  /**
-   * Specifies that the grammar recognized by the regular expression engine is
-   * that used by ECMAScript in ECMA-262 [Ecma International, ECMAScript
-   * Language Specification, Standard Ecma-262, third edition, 1999], as
-   * modified in tr1 section [7.13].  This grammar is similar to that defined
-   * in the PERL scripting language but extended with elements found in the
-   * POSIX regular expression grammar.
-   */
-  static const syntax_option_type ECMAScript = 1 << _S_ECMAScript;
-
-  /**
-   * Specifies that the grammar recognized by the regular expression engine is
-   * that used by POSIX basic regular expressions in IEEE Std 1003.1-2001,
-   * Portable Operating System Interface (POSIX), Base Definitions and
-   * Headers, Section 9, Regular Expressions [IEEE, Information Technology --
-   * Portable Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
-   */
-  static const syntax_option_type basic      = 1 << _S_basic;
-
-  /**
-   * Specifies that the grammar recognized by the regular expression engine is
-   * that used by POSIX extended regular expressions in IEEE Std 1003.1-2001,
-   * Portable Operating System Interface (POSIX), Base Definitions and Headers,
-   * Section 9, Regular Expressions.
-   */
-  static const syntax_option_type extended   = 1 << _S_extended;
-
-  /**
-   * Specifies that the grammar recognized by the regular expression engine is
-   * that used by POSIX utility awk in IEEE Std 1003.1-2001.  This option is
-   * identical to syntax_option_type extended, except that C-style escape
-   * sequences are supported.  These sequences are, explicitly, "\\", "\a",
-   * "\b", "\f", "\n", "\r", "\t" , "\v", "\"", "'",
-   * and "\ddd" (where ddd is one, two, or three octal digits).  
-   */
-  static const syntax_option_type awk        = 1 << _S_awk;
-
-  /**
-   * Specifies that the grammar recognized by the regular expression engine is
-   * that used by POSIX utility grep in IEEE Std 1003.1-2001.  This option is
-   * identical to syntax_option_type basic, except that newlines are treated
-   * as whitespace.
-   */
-  static const syntax_option_type grep       = 1 << _S_grep;
-
-  /**
-   * Specifies that the grammar recognized by the regular expression engine is
-   * that used by POSIX utility grep when given the -E option in
-   * IEEE Std 1003.1-2001.  This option is identical to syntax_option_type 
-   * extended, except that newlines are treated as whitespace.
-   */
-  static const syntax_option_type egrep      = 1 << _S_egrep;
-
-  //@}
-
-  /**
-   * @name 5.2 Matching Rules
-   *
-   * Matching a regular expression against a sequence of characters [first,
-   * last) proceeds according to the rules of the grammar specified for the
-   * regular expression object, modified according to the effects listed
-   * below for any bitmask elements set.
-   *
-   */
-  //@{
-
-  enum __match_flag
-    {
-      _S_not_bol,
-      _S_not_eol,
-      _S_not_bow,
-      _S_not_eow,
-      _S_any,
-      _S_not_null,
-      _S_continuous,
-      _S_prev_avail,
-      _S_sed,
-      _S_no_copy,
-      _S_first_only,
-      _S_match_flag_last
-    };
-
-  /**
-   * @brief This is a bitmask type indicating regex matching rules.
-   *
-   * The @c match_flag_type is implementation defined but it is valid to
-   * perform bitwise operations on these values and expect the right thing to
-   * happen.
-   */
-  typedef std::bitset<_S_match_flag_last> match_flag_type;
-
-  /**
-   * The default matching rules.
-   */
-  static const match_flag_type match_default     = 0;
-
-  /**
-   * The first character in the sequence [first, last) is treated as though it
-   * is not at the beginning of a line, so the character "^" in the regular
-   * expression shall not match [first, first).
-   */
-  static const match_flag_type match_not_bol     = 1 << _S_not_bol;
-
-  /**
-   * The last character in the sequence [first, last) is treated as though it
-   * is not at the end of a line, so the character "$" in the regular
-   * expression shall not match [last, last).
-   */
-  static const match_flag_type match_not_eol     = 1 << _S_not_eol;
-   
-  /**
-   * The expression "\b" is not matched against the sub-sequence
-   * [first,first).
-   */
-  static const match_flag_type match_not_bow     = 1 << _S_not_bow;
-   
-  /**
-   * The expression "\b" should not be matched against the sub-sequence
-   * [last,last).
-   */
-  static const match_flag_type match_not_eow     = 1 << _S_not_eow;
-   
-  /**
-   * If more than one match is possible then any match is an acceptable
-   * result.
-   */
-  static const match_flag_type match_any         = 1 << _S_any;
-   
-  /**
-   * The expression does not match an empty sequence.
-   */
-  static const match_flag_type match_not_null    = 1 << _S_not_null;
-   
-  /**
-   * The expression only matches a sub-sequence that begins at first .
-   */
-  static const match_flag_type match_continuous  = 1 << _S_continuous;
-   
-  /**
-   * --first is a valid iterator position.  When this flag is set then the
-   * flags match_not_bol and match_not_bow are ignored by the regular
-   * expression algorithms 7.11 and iterators 7.12.
-   */
-  static const match_flag_type match_prev_avail  = 1 << _S_prev_avail;
-
-  /**
-   * When a regular expression match is to be replaced by a new string, the
-   * new string is constructed using the rules used by the ECMAScript replace
-   * function in ECMA- 262 [Ecma International, ECMAScript Language
-   * Specification, Standard Ecma-262, third edition, 1999], part 15.5.4.11
-   * String.prototype.replace. In addition, during search and replace
-   * operations all non-overlapping occurrences of the regular expression
-   * are located and replaced, and sections of the input that did not match
-   * the expression are copied unchanged to the output string.
-   * 
-   * Format strings (from ECMA-262 [15.5.4.11]):
-   * @li $$  The dollar-sign itself ($)
-   * @li $&  The matched substring.
-   * @li $`  The portion of <em>string</em> that precedes the matched substring.
-   *         This would be match_results::prefix().
-   * @li $'  The portion of <em>string</em> that follows the matched substring.
-   *         This would be match_results::suffix().
-   * @li $n  The nth capture, where n is in [1,9] and $n is not followed by a
-   *         decimal digit.  If n <= match_results::size() and the nth capture
-   *         is undefined, use the empty string instead.  If n >
-   *         match_results::size(), the result is implementation-defined.
-   * @li $nn The nnth capture, where nn is a two-digit decimal number on
-   *         [01, 99].  If nn <= match_results::size() and the nth capture is
-   *         undefined, use the empty string instead. If
-   *         nn > match_results::size(), the result is implementation-defined.
-   */
-  static const match_flag_type format_default    = 0;
-
-  /**
-   * When a regular expression match is to be replaced by a new string, the
-   * new string is constructed using the rules used by the POSIX sed utility
-   * in IEEE Std 1003.1- 2001 [IEEE, Information Technology -- Portable
-   * Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
-   */
-  static const match_flag_type format_sed        = 1 << _S_sed;
-
-  /**
-   * During a search and replace operation, sections of the character
-   * container sequence being searched that do not match the regular
-   * expression shall not be copied to the output string.
-   */
-  static const match_flag_type format_no_copy    = 1 << _S_no_copy;
-
-  /**
-   * When specified during a search and replace operation, only the first
-   * occurrence of the regular expression shall be replaced.
-   */
-  static const match_flag_type format_first_only = 1 << _S_first_only;
-
-  //@}
-
-  /**
-   * @name 5.3 Error Types
-   */
-  //@{
- 
-  enum error_type
-    {
-      _S_error_collate,
-      _S_error_ctype,
-      _S_error_escape,
-      _S_error_backref,
-      _S_error_brack,
-      _S_error_paren,
-      _S_error_brace,
-      _S_error_badbrace,
-      _S_error_range,
-      _S_error_space,
-      _S_error_badrepeat,
-      _S_error_complexity,
-      _S_error_stack,
-      _S_error_last
-    };
-
-  /** The expression contained an invalid collating element name. */
-  static const error_type error_collate(_S_error_collate);
-
-  /** The expression contained an invalid character class name. */
-  static const error_type error_ctype(_S_error_ctype);
-
-  /**
-   * The expression contained an invalid escaped character, or a trailing
-   * escape.
-   */
-  static const error_type error_escape(_S_error_escape);
-
-  /** The expression contained an invalid back reference. */
-  static const error_type error_backref(_S_error_backref);
-
-  /** The expression contained mismatched [ and ]. */
-  static const error_type error_brack(_S_error_brack);
-
-  /** The expression contained mismatched ( and ). */
-  static const error_type error_paren(_S_error_paren);
-
-  /** The expression contained mismatched { and } */
-  static const error_type error_brace(_S_error_brace);
-
-  /** The expression contained an invalid range in a {} expression. */
-  static const error_type error_badbrace(_S_error_badbrace);
-
-  /**
-   * The expression contained an invalid character range,
-   * such as [b-a] in most encodings.
-   */
-  static const error_type error_range(_S_error_range);
-
-  /**
-   * There was insufficient memory to convert the expression into a
-   * finite state machine.
-   */
-  static const error_type error_space(_S_error_space);
-
-  /**
-   * One of "*?+{" was not preceded by a valid regular expression.
-   */
-  static const error_type error_badrepeat(_S_error_badrepeat);
-
-  /**
-   * The complexity of an attempted match against a regular expression
-   * exceeded a pre-set level.
-   */
-  static const error_type error_complexity(_S_error_complexity);
-
-  /**
-   * There was insufficient memory to determine whether the
-   * regular expression could match the specified character sequence.
-   */
-  static const error_type error_stack(_S_error_stack);
-
-  //@}
-}
-
-
-  // [7.8] Class regex_error
-  /**
-   *  @brief A regular expression exception class.
-   *  @ingroup exceptions
-   *
-   *  The regular expression library throws objects of this class on error.
-   */
-  class regex_error
-  : public std::runtime_error
-  {
-  public:
-    /**
-     * @brief Constructs a regex_error object.
-     *
-     * @param ecode the regex error code.
-     */
-    explicit
-    regex_error(regex_constants::error_type __ecode)
-    : std::runtime_error("regex_error"), _M_code(__ecode)
-    { }
-
-    /**
-     * @brief Gets the regex error code.
-     *
-     * @returns the regex error code.
-     */
-    regex_constants::error_type
-    code() const
-    { return _M_code; }
-
-  protected:
-    regex_constants::error_type _M_code;
-  };
-
-  // [7.7] Class regex_traits
-  /**
-   * @brief Describes aspects of a regular expression.
-   *
-   * A regular expression traits class that satisfies the requirements of tr1
-   * section [7.2].
-   *
-   * The class %regex is parameterized around a set of related types and
-   * functions used to complete the definition of its semantics.  This class
-   * satisfies the requirements of such a traits class.
-   */
-  template<typename _Ch_type>
-    struct regex_traits
-    {
-    public:
-      typedef _Ch_type                     char_type;
-      typedef std::basic_string<char_type> string_type;
-      typedef std::locale                  locale_type;
-      typedef std::ctype_base::mask        char_class_type;
-
-    public:
-      /**
-       * @brief Constructs a default traits object.
-       */
-      regex_traits()
-      { }
-      
-      /**
-       * @brief Gives the length of a C-style string starting at @p __p.
-       *
-       * @param __p a pointer to the start of a character sequence.
-       *
-       * @returns the number of characters between @p *__p and the first
-       * default-initialized value of type @p char_type.  In other words, uses
-       * the C-string algorithm for determining the length of a sequence of
-       * characters.
-       */
-      static std::size_t
-      length(const char_type* __p)
-      { return string_type::traits_type::length(__p); }
-
-      /**
-       * @brief Performs the identity translation.
-       *
-       * @param c A character to the locale-specific character set.
-       *
-       * @returns c.
-       */
-      char_type
-      translate(char_type __c) const
-      { return __c; }
-      
-      /**
-       * @brief Translates a character into a case-insensitive equivalent.
-       *
-       * @param c A character to the locale-specific character set.
-       *
-       * @returns the locale-specific lower-case equivalent of c.
-       * @throws std::bad_cast if the imbued locale does not support the ctype
-       *         facet.
-       */
-      char_type
-      translate_nocase(char_type __c) const
-      {
-	using std::ctype;
-	using std::use_facet;
-	return use_facet<ctype<char_type> >(_M_locale).tolower(__c);
-      }
-      
-      /**
-       * @brief Gets a sort key for a character sequence.
-       *
-       * @param first beginning of the character sequence.
-       * @param last  one-past-the-end of the character sequence.
-       *
-       * Returns a sort key for the character sequence designated by the
-       * iterator range [F1, F2) such that if the character sequence [G1, G2)
-       * sorts before the character sequence [H1, H2) then
-       * v.transform(G1, G2) < v.transform(H1, H2).
-       *
-       * What this really does is provide a more efficient way to compare a
-       * string to multiple other strings in locales with fancy collation
-       * rules and equivalence classes.
-       *
-       * @returns a locale-specific sort key equivalent to the input range.
-       *
-       * @throws std::bad_cast if the current locale does not have a collate
-       *         facet.
-       */
-      template<typename _Fwd_iter>
-        string_type
-        transform(_Fwd_iter __first, _Fwd_iter __last) const
-        {
-	  using std::collate;
-	  using std::use_facet;
-	  const collate<_Ch_type>& __c(use_facet<
-				       collate<_Ch_type> >(_M_locale));
-	  string_type __s(__first, __last);
-	  return __c.transform(__s.data(), __s.data() + __s.size());
-	}
-
-      /**
-       * @brief Dunno.
-       *
-       * @param first beginning of the character sequence.
-       * @param last  one-past-the-end of the character sequence.
-       *
-       * Effects: if typeid(use_facet<collate<_Ch_type> >) ==
-       * typeid(collate_byname<_Ch_type>) and the form of the sort key
-       * returned by collate_byname<_Ch_type>::transform(first, last) is known
-       * and can be converted into a primary sort key then returns that key,
-       * otherwise returns an empty string. WTF??
-       *
-       * @todo Implement this function.
-       */
-      template<typename _Fwd_iter>
-        string_type
-        transform_primary(_Fwd_iter __first, _Fwd_iter __last) const;
-
-      /**
-       * @brief Gets a collation element by name.
-       *
-       * @param first beginning of the collation element name.
-       * @param last  one-past-the-end of the collation element name.
-       * 
-       * @returns a sequence of one or more characters that represents the
-       * collating element consisting of the character sequence designated by
-       * the iterator range [first, last). Returns an empty string if the
-       * character sequence is not a valid collating element.
-       *
-       * @todo Implement this function.
-       */
-      template<typename _Fwd_iter>
-        string_type
-        lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const;
-
-      /**
-       * @brief Maps one or more characters to a named character
-       *        classification.
-       *
-       * @param first beginning of the character sequence.
-       * @param last  one-past-the-end of the character sequence.
-       *
-       * @returns an unspecified value that represents the character
-       * classification named by the character sequence designated by the
-       * iterator range [first, last). The value returned shall be independent
-       * of the case of the characters in the character sequence. If the name
-       * is not recognized then returns a value that compares equal to 0.
-       *
-       * At least the following names (or their wide-character equivalent) are
-       * supported.
-       * - d
-       * - w
-       * - s
-       * - alnum
-       * - alpha
-       * - blank
-       * - cntrl
-       * - digit
-       * - graph
-       * - lower
-       * - print
-       * - punct
-       * - space
-       * - upper
-       * - xdigit
-       *
-       * @todo Implement this function.
-       */
-      template<typename _Fwd_iter>
-        char_class_type
-        lookup_classname(_Fwd_iter __first, _Fwd_iter __last) const;
-
-      /**
-       * @brief Determines if @p c is a member of an identified class.
-       *
-       * @param c a character.
-       * @param f a class type (as returned from lookup_classname).
-       *
-       * @returns true if the character @p c is a member of the classification
-       * represented by @p f, false otherwise.
-       *
-       * @throws std::bad_cast if the current locale does not have a ctype
-       *         facet.
-       */
-      bool
-      isctype(_Ch_type __c, char_class_type __f) const;
-
-      /**
-       * @brief Converts a digit to an int.
-       *
-       * @param ch    a character representing a digit.
-       * @param radix the radix if the numeric conversion (limited to 8, 10,
-       *              or 16).
-       * 
-       * @returns the value represented by the digit ch in base radix if the
-       * character ch is a valid digit in base radix; otherwise returns -1.
-       */
-      int
-      value(_Ch_type __ch, int __radix) const;
-      
-      /**
-       * @brief Imbues the regex_traits object with a copy of a new locale.
-       *
-       * @param loc A locale.
-       *
-       * @returns a copy of the previous locale in use by the regex_traits
-       *          object.
-       *
-       * @note Calling imbue with a different locale than the one currently in
-       *       use invalidates all cached data held by *this.
-       */
-      locale_type
-      imbue(locale_type __loc)
-      {
-	std::swap(_M_locale, __loc);
-	return __loc;
-      }
-      
-      /**
-       * @brief Gets a copy of the current locale in use by the regex_traits
-       * object.
-       */
-      locale_type
-      getloc() const
-      { return _M_locale; }
-      
-    protected:
-      locale_type _M_locale;
-    };
-
-  template<typename _Ch_type>
-    bool regex_traits<_Ch_type>::
-    isctype(_Ch_type __c, char_class_type __f) const
-    {
-      using std::ctype;
-      using std::use_facet;
-      const ctype<_Ch_type>& __ctype(use_facet<
-				     ctype<_Ch_type> >(_M_locale));
-      
-      if (__ctype.is(__c, __f))
-	return true;
-      
-      // special case of underscore in [[:w:]]
-      if (__c == __ctype.widen('_'))
-	{
-	  const char* const __wb[] = "w";
-	  char_class_type __wt = this->lookup_classname(__wb,
-							__wb + sizeof(__wb));
-	  if (__f | __wt)
-	    return true;
-	}
-    
-      // special case of [[:space:]] in [[:blank:]]
-      if (__c == __ctype.isspace(__c))
-	{
-	  const char* const __bb[] = "blank";
-	  char_class_type __bt = this->lookup_classname(__bb,
-							__bb + sizeof(__bb));
-	  if (__f | __bt)
-	    return true;
-	}
-      
-      return false;
-    }
-
-  template<typename _Ch_type>
-    int regex_traits<_Ch_type>::
-    value(_Ch_type __ch, int __radix) const
-    {
-      std::basic_istringstream<_Ch_type> __is(string_type(1, __ch));
-      int __v = -1;
-      if (__radix == 8)
-	__is >> std::oct;
-      else if (__radix == 16)
-	__is >> std::hex;
-      __is >> __v;
-      return __v;
-    }
-
-  // [7.8] Class basic_regex
-  /**
-   * Objects of specializations of this class represent regular expressions
-   * constructed from sequences of character type @p _Ch_type.
-   *
-   * Storage for the regular expression is allocated and deallocated as
-   * necessary by the member functions of this class.
-   */
-  template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type> >
-    class basic_regex
-    {
-    public:
-      // types:
-      typedef _Ch_type                              value_type;
-      typedef regex_constants::syntax_option_type flag_type;
-      typedef typename _Rx_traits::locale_type  locale_type;
-      typedef typename _Rx_traits::string_type  string_type;
-
-      /**
-       * @name Constants
-       * tr1 [7.8.1] std [28.8.1]
-       */
-      //@{
-      static const regex_constants::syntax_option_type icase
-        = regex_constants::icase;
-      static const regex_constants::syntax_option_type nosubs
-        = regex_constants::nosubs;
-      static const regex_constants::syntax_option_type optimize
-        = regex_constants::optimize;
-      static const regex_constants::syntax_option_type collate
-        = regex_constants::collate;
-      static const regex_constants::syntax_option_type ECMAScript
-        = regex_constants::ECMAScript;
-      static const regex_constants::syntax_option_type basic
-        = regex_constants::basic;
-      static const regex_constants::syntax_option_type extended
-        = regex_constants::extended;
-      static const regex_constants::syntax_option_type awk
-        = regex_constants::awk;
-      static const regex_constants::syntax_option_type grep
-        = regex_constants::grep;
-      static const regex_constants::syntax_option_type egrep
-        = regex_constants::egrep;
-      //@}
-
-      // [7.8.2] construct/copy/destroy
-      /**
-       * Constructs a basic regular expression that does not match any
-       * character sequence.
-       */
-      basic_regex()
-      : _M_flags(regex_constants::ECMAScript), _M_pattern(), _M_mark_count(0)
-      { _M_compile(); }
-
-      /**
-       * @brief Constructs a basic regular expression from the sequence
-       * [p, p + char_traits<_Ch_type>::length(p)) interpreted according to the
-       * flags in @p f.
-       *
-       * @param p A pointer to the start of a C-style null-terminated string
-       *          containing a regular expression.
-       * @param f Flags indicating the syntax rules and options.
-       *
-       * @throws regex_error if @p p is not a valid regular expression.
-       */
-      explicit
-      basic_regex(const _Ch_type* __p,
-		  flag_type __f = regex_constants::ECMAScript)
-      : _M_flags(__f), _M_pattern(__p), _M_mark_count(0)
-      { _M_compile(); }
-
-      /**
-       * @brief Constructs a basic regular expression from the sequence
-       * [p, p + len) interpreted according to the flags in @p f.
-       *
-       * @param p   A pointer to the start of a string containing a regular
-       *            expression.
-       * @param len The length of the string containing the regular expression.
-       * @param f   Flags indicating the syntax rules and options.
-       *
-       * @throws regex_error if @p p is not a valid regular expression.
-       */
-      basic_regex(const _Ch_type* __p, std::size_t __len, flag_type __f)
-      : _M_flags(__f) , _M_pattern(__p, __len), _M_mark_count(0)
-      { _M_compile(); }
-
-      /**
-       * @brief Copy-constructs a basic regular expression.
-       *
-       * @param rhs A @p regex object.
-     */
-      basic_regex(const basic_regex& __rhs)
-      : _M_flags(__rhs._M_flags), _M_pattern(__rhs._M_pattern),
-	_M_mark_count(__rhs._M_mark_count)
-      { _M_compile(); }
-
-      /**
-       * @brief Constructs a basic regular expression from the string
-       * @p s interpreted according to the flags in @p f.
-       *
-       * @param s A string containing a regular expression.
-       * @param f Flags indicating the syntax rules and options.
-       *
-       * @throws regex_error if @p s is not a valid regular expression.
-       */
-      template<typename _Ch_traits, typename _Ch_alloc>
-        explicit
-        basic_regex(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
-		    flag_type __f = regex_constants::ECMAScript)
-	: _M_flags(__f), _M_pattern(__s.begin(), __s.end()), _M_mark_count(0)
-        { _M_compile(); }
-
-      /**
-       * @brief Constructs a basic regular expression from the range
-       * [first, last) interpreted according to the flags in @p f.
-       *
-       * @param first The start of a range containing a valid regular
-       *              expression.
-       * @param last  The end of a range containing a valid regular
-       *              expression.
-       * @param f     The format flags of the regular expression.
-       *
-       * @throws regex_error if @p [first, last) is not a valid regular
-       *         expression.
-       */
-      template<typename _InputIterator>
-        basic_regex(_InputIterator __first, _InputIterator __last, 
-		    flag_type __f = regex_constants::ECMAScript)
-	: _M_flags(__f), _M_pattern(__first, __last), _M_mark_count(0)
-        { _M_compile(); }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      /**
-       * @brief Constructs a basic regular expression from an initializer list.
-       *
-       * @param l  The initializer list.
-       * @param f  The format flags of the regular expression.
-       *
-       * @throws regex_error if @p l is not a valid regular expression.
-       */
-      basic_regex(initializer_list<_Ch_type> __l,
-		  flag_type __f = regex_constants::ECMAScript)
-	: _M_flags(__f), _M_pattern(__l.begin(), __l.end()), _M_mark_count(0)
-        { _M_compile(); }
-#endif
-
-      /**
-       * @brief Destroys a basic regular expression.
-       */
-      ~basic_regex()
-      { }
-      
-      /**
-       * @brief Assigns one regular expression to another.
-       */
-      basic_regex&
-      operator=(const basic_regex& __rhs)
-      { return this->assign(__rhs); }
-
-      /**
-       * @brief Replaces a regular expression with a new one constructed from
-       * a C-style null-terminated string.
-       *
-       * @param A pointer to the start of a null-terminated C-style string
-       *        containing a regular expression.
-       */
-      basic_regex&
-      operator=(const _Ch_type* __p)
-      { return this->assign(__p, flags()); }
-      
-      /**
-       * @brief Replaces a regular expression with a new one constructed from
-       * a string.
-       *
-       * @param A pointer to a string containing a regular expression.
-       */
-      template<typename _Ch_typeraits, typename _Allocator>
-        basic_regex&
-        operator=(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s)
-        { return this->assign(__s, flags()); }
-
-      // [7.8.3] assign
-      /**
-       * @brief the real assignment operator.
-       *
-       * @param that Another regular expression object.
-       */
-      basic_regex&
-      assign(const basic_regex& __that)
-      {
-	basic_regex __tmp(__that);
-	this->swap(__tmp);
-	return *this;
-      }
-      
-      /**
-       * @brief Assigns a new regular expression to a regex object from a
-       * C-style null-terminated string containing a regular expression
-       * pattern.
-       *
-       * @param p     A pointer to a C-style null-terminated string containing
-       *              a regular expression pattern.
-       * @param flags Syntax option flags.
-       *
-       * @throws regex_error if p does not contain a valid regular expression
-       * pattern interpreted according to @p flags.  If regex_error is thrown,
-       * *this remains unchanged.
-       */
-      basic_regex&
-      assign(const _Ch_type* __p,
-	     flag_type __flags = regex_constants::ECMAScript)
-      { return this->assign(string_type(__p), __flags); }
-
-      /**
-       * @brief Assigns a new regular expression to a regex object from a
-       * C-style string containing a regular expression pattern.
-       *
-       * @param p     A pointer to a C-style string containing a
-       *              regular expression pattern.
-       * @param len   The length of the regular expression pattern string.
-       * @param flags Syntax option flags.
-       *
-       * @throws regex_error if p does not contain a valid regular expression
-       * pattern interpreted according to @p flags.  If regex_error is thrown,
-       * *this remains unchanged.
-       */
-      basic_regex&
-      assign(const _Ch_type* __p, std::size_t __len, flag_type __flags)
-      { return this->assign(string_type(__p, __len), __flags); }
-
-      /**
-       * @brief Assigns a new regular expression to a regex object from a 
-       * string containing a regular expression pattern.
-       *
-       * @param s     A string containing a regular expression pattern.
-       * @param flags Syntax option flags.
-       *
-       * @throws regex_error if p does not contain a valid regular expression
-       * pattern interpreted according to @p flags.  If regex_error is thrown,
-       * *this remains unchanged.
-       */
-      template<typename _Ch_typeraits, typename _Allocator>
-        basic_regex&
-        assign(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s,
-	       flag_type __f = regex_constants::ECMAScript)
-        { 
-	  basic_regex __tmp(__s, __f);
-	  this->swap(__tmp);
-	  return *this;
-	}
-
-      /**
-       * @brief Assigns a new regular expression to a regex object.
-       *
-       * @param first The start of a range containing a valid regular
-       *              expression.
-       * @param last  The end of a range containing a valid regular
-       *              expression.
-       * @param flags Syntax option flags.
-       *
-       * @throws regex_error if p does not contain a valid regular expression
-       * pattern interpreted according to @p flags.  If regex_error is thrown,
-       * the object remains unchanged.
-       */
-      template<typename _InputIterator>
-        basic_regex&
-        assign(_InputIterator __first, _InputIterator __last,
-	       flag_type __flags = regex_constants::ECMAScript)
-        { return this->assign(string_type(__first, __last), __flags); }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      /**
-       * @brief Assigns a new regular expression to a regex object.
-       *
-       * @param l     An initializer list representing a regular expression.
-       * @param flags Syntax option flags.
-       *
-       * @throws regex_error if @p l does not contain a valid regular
-       * expression pattern interpreted according to @p flags.  If regex_error
-       * is thrown, the object remains unchanged.
-       */
-      basic_regex&
-      assign(initializer_list<_Ch_type> __l,
-	     flag_type __f = regex_constants::ECMAScript)
-      { return this->assign(__l.begin(), __l.end(), __f); }
-#endif
-
-      // [7.8.4] const operations
-      /**
-       * @brief Gets the number of marked subexpressions within the regular
-       * expression.
-       */
-      unsigned int
-      mark_count() const
-      { return _M_mark_count; }
-      
-      /**
-       * @brief Gets the flags used to construct the regular expression
-       * or in the last call to assign().
-       */
-      flag_type
-      flags() const
-      { return _M_flags; }
-      
-      // [7.8.5] locale
-      /**
-       * @brief Imbues the regular expression object with the given locale.
-       *
-       * @param loc A locale.
-       */
-      locale_type
-      imbue(locale_type __loc)
-      { return _M_traits.imbue(__loc); }
-      
-      /**
-       * @brief Gets the locale currently imbued in the regular expression
-       *        object.
-       */
-      locale_type
-      getloc() const
-      { return _M_traits.getloc(); }
-      
-      // [7.8.6] swap
-      /**
-       * @brief Swaps the contents of two regular expression objects.
-       *
-       * @param rhs Another regular expression object.
-       */
-      void
-      swap(basic_regex& __rhs)
-      {
-	std::swap(_M_flags,      __rhs._M_flags);
-	std::swap(_M_pattern,    __rhs._M_pattern);
-	std::swap(_M_mark_count, __rhs._M_mark_count);
-	std::swap(_M_traits,     __rhs._M_traits);
-      }
-      
-    private:
-      /**
-       * @brief Compiles a regular expression pattern into a NFA.
-       * @todo Implement this function.
-       */
-      void _M_compile();
-
-    protected:
-      flag_type    _M_flags;
-      string_type  _M_pattern;
-      unsigned int _M_mark_count;
-      _Rx_traits   _M_traits;
-    };
-  
-  /** @brief Standard regular expressions. */
-  typedef basic_regex<char>    regex;
-#ifdef _GLIBCXX_USE_WCHAR_T
-  /** @brief Standard wide-character regular expressions. */
-  typedef basic_regex<wchar_t> wregex;
-#endif
-
-
-  // [7.8.6] basic_regex swap
-  /**
-   * @brief Swaps the contents of two regular expression objects.
-   * @param lhs First regular expression.
-   * @param rhs Second regular expression.
-   */
-  template<typename _Ch_type, typename _Rx_traits>
-    inline void
-    swap(basic_regex<_Ch_type, _Rx_traits>& __lhs,
-	 basic_regex<_Ch_type, _Rx_traits>& __rhs)
-    { __lhs.swap(__rhs); }
-
-
-  // [7.9] Class template sub_match
-  /**
-   * A sequence of characters matched by a particular marked sub-expression.
-   *
-   * An object of this class is essentially a pair of iterators marking a
-   * matched subexpression within a regular expression pattern match. Such
-   * objects can be converted to and compared with std::basic_string objects
-   * of a similar base character type as the pattern matched by the regular
-   * expression.
-   *
-   * The iterators that make up the pair are the usual half-open interval
-   * referencing the actual original pattern matched.
-   */
-  template<typename _BiIter>
-    class sub_match : public std::pair<_BiIter, _BiIter>
-    {
-    public:
-      typedef typename iterator_traits<_BiIter>::value_type      value_type;
-      typedef typename iterator_traits<_BiIter>::difference_type
-                                                            difference_type;
-      typedef _BiIter                                              iterator;
-
-    public:
-      bool matched;
-      
-      /**
-       * Gets the length of the matching sequence.
-       */
-      difference_type
-      length() const
-      { return this->matched ? std::distance(this->first, this->second) : 0; }
-
-      /**
-       * @brief Gets the matching sequence as a string.
-       *
-       * @returns the matching sequence as a string.
-       *
-       * This is the implicit conversion operator.  It is identical to the
-       * str() member function except that it will want to pop up in
-       * unexpected places and cause a great deal of confusion and cursing
-       * from the unwary.
-       */
-      operator basic_string<value_type>() const
-      {
-	return this->matched
-	  ? std::basic_string<value_type>(this->first, this->second)
-	  : std::basic_string<value_type>();
-      }
-      
-      /**
-       * @brief Gets the matching sequence as a string.
-       *
-       * @returns the matching sequence as a string.
-       */
-      basic_string<value_type>
-      str() const
-      {
-	return this->matched
-	  ? std::basic_string<value_type>(this->first, this->second)
-	  : std::basic_string<value_type>();
-      }
-      
-      /**
-       * @brief Compares this and another matched sequence.
-       *
-       * @param s Another matched sequence to compare to this one.
-       *
-       * @retval <0 this matched sequence will collate before @p s.
-       * @retval =0 this matched sequence is equivalent to @p s.
-       * @retval <0 this matched sequence will collate after @p s.
-       */
-      int
-      compare(const sub_match& __s) const
-      { return this->str().compare(__s.str()); }
-
-      /**
-       * @brief Compares this sub_match to a string.
-       *
-       * @param s A string to compare to this sub_match.
-       *
-       * @retval <0 this matched sequence will collate before @p s.
-       * @retval =0 this matched sequence is equivalent to @p s.
-       * @retval <0 this matched sequence will collate after @p s.
-       */
-      int
-      compare(const basic_string<value_type>& __s) const
-      { return this->str().compare(__s); }
-      
-      /**
-       * @brief Compares this sub_match to a C-style string.
-       *
-       * @param s A C-style string to compare to this sub_match.
-       *
-       * @retval <0 this matched sequence will collate before @p s.
-       * @retval =0 this matched sequence is equivalent to @p s.
-       * @retval <0 this matched sequence will collate after @p s.
-       */
-      int
-      compare(const value_type* __s) const
-      { return this->str().compare(__s); }
-    };
-  
-  
-  /** @brief Standard regex submatch over a C-style null-terminated string. */
-  typedef sub_match<const char*>             csub_match;
-  /** @brief Standard regex submatch over a standard string. */
-  typedef sub_match<string::const_iterator>  ssub_match;
-#ifdef _GLIBCXX_USE_WCHAR_T
-  /** @brief Regex submatch over a C-style null-terminated wide string. */
-  typedef sub_match<const wchar_t*>          wcsub_match;
-  /** @brief Regex submatch over a standard wide string. */
-  typedef sub_match<wstring::const_iterator> wssub_match;
-#endif
-
-  // [7.9.2] sub_match non-member operators
-  
-  /**
-   * @brief Tests the equivalence of two regular expression submatches.
-   * @param lhs First regular expression submatch.
-   * @param rhs Second regular expression submatch.
-   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
-   */
-  template<typename _BiIter>
-    inline bool
-    operator==(const sub_match<_BiIter>& __lhs,
-	       const sub_match<_BiIter>& __rhs)
-    { return __lhs.compare(__rhs) == 0; }
-
-  /**
-   * @brief Tests the inequivalence of two regular expression submatches.
-   * @param lhs First regular expression submatch.
-   * @param rhs Second regular expression submatch.
-   * @returns true if @a lhs  is not equivalent to @a rhs, false otherwise.
-   */
-  template<typename _BiIter>
-    inline bool
-    operator!=(const sub_match<_BiIter>& __lhs,
-	       const sub_match<_BiIter>& __rhs)
-    { return __lhs.compare(__rhs) != 0; }
-
-  /**
-   * @brief Tests the ordering of two regular expression submatches.
-   * @param lhs First regular expression submatch.
-   * @param rhs Second regular expression submatch.
-   * @returns true if @a lhs precedes @a rhs, false otherwise.
-   */
-  template<typename _BiIter>
-    inline bool
-    operator<(const sub_match<_BiIter>& __lhs,
-	      const sub_match<_BiIter>& __rhs)
-    { return __lhs.compare(__rhs) < 0; }
-
-  /**
-   * @brief Tests the ordering of two regular expression submatches.
-   * @param lhs First regular expression submatch.
-   * @param rhs Second regular expression submatch.
-   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
-   */
-  template<typename _BiIter>
-    inline bool
-    operator<=(const sub_match<_BiIter>& __lhs,
-	       const sub_match<_BiIter>& __rhs)
-    { return __lhs.compare(__rhs) <= 0; }
-
-  /**
-   * @brief Tests the ordering of two regular expression submatches.
-   * @param lhs First regular expression submatch.
-   * @param rhs Second regular expression submatch.
-   * @returns true if @a lhs does not precede @a rhs, false otherwise.
-   */
-  template<typename _BiIter>
-    inline bool
-    operator>=(const sub_match<_BiIter>& __lhs,
-	       const sub_match<_BiIter>& __rhs)
-    { return __lhs.compare(__rhs) >= 0; }
-
-  /**
-   * @brief Tests the ordering of two regular expression submatches.
-   * @param lhs First regular expression submatch.
-   * @param rhs Second regular expression submatch.
-   * @returns true if @a lhs succeeds @a rhs, false otherwise.
-   */
-  template<typename _BiIter>
-    inline bool
-    operator>(const sub_match<_BiIter>& __lhs,
-	      const sub_match<_BiIter>& __rhs)
-    { return __lhs.compare(__rhs) > 0; }
-
-  /**
-   * @brief Tests the equivalence of a string and a regular expression
-   *        submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
-    inline bool
-    operator==(const basic_string<
-	       typename iterator_traits<_Bi_iter>::value_type,
-	       _Ch_traits, _Ch_alloc>& __lhs,
-	       const sub_match<_Bi_iter>& __rhs)
-    { return __lhs == __rhs.str(); }
-
-  /**
-   * @brief Tests the inequivalence of a string and a regular expression
-   *        submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs  is not equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
-    inline bool
-    operator!=(const basic_string<
-	       typename iterator_traits<_Bi_iter>::value_type,
-	       _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
-    { return __lhs != __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs precedes @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
-    inline bool
-    operator<(const basic_string<
-	      typename iterator_traits<_Bi_iter>::value_type,
-	      _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
-     { return __lhs < __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs succeeds @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
-    inline bool
-    operator>(const basic_string<
-	      typename iterator_traits<_Bi_iter>::value_type, 
-	      _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
-    { return __lhs > __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs does not precede @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
-    inline bool
-    operator>=(const basic_string<
-	       typename iterator_traits<_Bi_iter>::value_type,
-	       _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
-    { return __lhs >= __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
-    inline bool
-    operator<=(const basic_string<
-	       typename iterator_traits<_Bi_iter>::value_type,
-	       _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
-    { return __lhs <= __rhs.str(); }
-
-  /**
-   * @brief Tests the equivalence of a regular expression submatch and a
-   *        string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
-    inline bool
-    operator==(const sub_match<_Bi_iter>& __lhs,
-	       const basic_string<
-	       typename iterator_traits<_Bi_iter>::value_type,
-	       _Ch_traits, _Ch_alloc>& __rhs)
-    { return __lhs.str() == __rhs; }
-
-  /**
-   * @brief Tests the inequivalence of a regular expression submatch and a
-   *        string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
-    inline bool
-    operator!=(const sub_match<_Bi_iter>& __lhs,
-	       const basic_string<
-	       typename iterator_traits<_Bi_iter>::value_type,
-	       _Ch_traits, _Ch_alloc>& __rhs)
-    { return __lhs.str() != __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs precedes @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
-    inline bool
-    operator<(const sub_match<_Bi_iter>& __lhs,
-	      const basic_string<
-	      typename iterator_traits<_Bi_iter>::value_type,
-	      _Ch_traits, _Ch_alloc>& __rhs)
-    { return __lhs.str() < __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs succeeds @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
-    inline bool
-    operator>(const sub_match<_Bi_iter>& __lhs,
-	      const basic_string<
-	      typename iterator_traits<_Bi_iter>::value_type,
-	      _Ch_traits, _Ch_alloc>& __rhs)
-    { return __lhs.str() > __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs does not precede @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
-    inline bool
-    operator>=(const sub_match<_Bi_iter>& __lhs,
-	       const basic_string<
-	       typename iterator_traits<_Bi_iter>::value_type,
-	       _Ch_traits, _Ch_alloc>& __rhs)
-    { return __lhs.str() >= __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
-    inline bool
-    operator<=(const sub_match<_Bi_iter>& __lhs,
-	       const basic_string<
-	       typename iterator_traits<_Bi_iter>::value_type,
-	       _Ch_traits, _Ch_alloc>& __rhs)
-    { return __lhs.str() <= __rhs; }
-
-  /**
-   * @brief Tests the equivalence of a C string and a regular expression
-   *        submatch.
-   * @param lhs A C string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator==(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
-	       const sub_match<_Bi_iter>& __rhs)
-    { return __lhs == __rhs.str(); }
-
-  /**
-   * @brief Tests the inequivalence of an iterator value and a regular
-   *        expression submatch.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator!=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
-	       const sub_match<_Bi_iter>& __rhs)
-    { return __lhs != __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs precedes @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator<(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
-	      const sub_match<_Bi_iter>& __rhs)
-    { return __lhs < __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs succeeds @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator>(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
-	      const sub_match<_Bi_iter>& __rhs)
-    { return __lhs > __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs does not precede @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator>=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
-	       const sub_match<_Bi_iter>& __rhs)
-    { return __lhs >= __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator<=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
-	       const sub_match<_Bi_iter>& __rhs)
-    { return __lhs <= __rhs.str(); }
-
-  /**
-   * @brief Tests the equivalence of a regular expression submatch and a
-   *        string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A pointer to a string?
-   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator==(const sub_match<_Bi_iter>& __lhs,
-	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
-    { return __lhs.str() == __rhs; }
-
-  /**
-   * @brief Tests the inequivalence of a regular expression submatch and a
-   *        string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A pointer to a string.
-   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator!=(const sub_match<_Bi_iter>& __lhs,
-	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
-    { return __lhs.str() != __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs precedes @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator<(const sub_match<_Bi_iter>& __lhs,
-	      typename iterator_traits<_Bi_iter>::value_type const* __rhs)
-    { return __lhs.str() < __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs succeeds @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator>(const sub_match<_Bi_iter>& __lhs,
-	      typename iterator_traits<_Bi_iter>::value_type const* __rhs)
-    { return __lhs.str() > __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs does not precede @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator>=(const sub_match<_Bi_iter>& __lhs,
-	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
-    { return __lhs.str() >= __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A string.
-   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator<=(const sub_match<_Bi_iter>& __lhs,
-	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
-    { return __lhs.str() <= __rhs; }
-
-  /**
-   * @brief Tests the equivalence of a string and a regular expression
-   *        submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator==(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
-	       const sub_match<_Bi_iter>& __rhs)
-    { return __lhs == __rhs.str(); }
-
-  /**
-   * @brief Tests the inequivalence of a string and a regular expression
-   *        submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator!=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
-	       const sub_match<_Bi_iter>& __rhs)
-    { return __lhs != __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs precedes @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator<(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
-	      const sub_match<_Bi_iter>& __rhs)
-    { return __lhs < __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs succeeds @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator>(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
-	      const sub_match<_Bi_iter>& __rhs)
-    { return __lhs > __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs does not precede @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator>=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
-	       const sub_match<_Bi_iter>& __rhs)
-    { return __lhs >= __rhs.str(); }
-
-  /**
-   * @brief Tests the ordering of a string and a regular expression submatch.
-   * @param lhs A string.
-   * @param rhs A regular expression submatch.
-   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator<=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
-	       const sub_match<_Bi_iter>& __rhs)
-    { return __lhs <= __rhs.str(); }
-
-  /**
-   * @brief Tests the equivalence of a regular expression submatch and a
-   *        string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A const string reference.
-   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator==(const sub_match<_Bi_iter>& __lhs,
-	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
-    { return __lhs.str() == __rhs; }
-
-  /**
-   * @brief Tests the inequivalence of a regular expression submatch and a
-   *        string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A const string reference.
-   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator!=(const sub_match<_Bi_iter>& __lhs,
-	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
-    { return __lhs.str() != __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A const string reference.
-   * @returns true if @a lhs precedes @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator<(const sub_match<_Bi_iter>& __lhs,
-	      typename iterator_traits<_Bi_iter>::value_type const& __rhs)
-    { return __lhs.str() < __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A const string reference.
-   * @returns true if @a lhs succeeds @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator>(const sub_match<_Bi_iter>& __lhs,
-	      typename iterator_traits<_Bi_iter>::value_type const& __rhs)
-    { return __lhs.str() > __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A const string reference.
-   * @returns true if @a lhs does not precede @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator>=(const sub_match<_Bi_iter>& __lhs,
-	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
-    { return __lhs.str() >= __rhs; }
-
-  /**
-   * @brief Tests the ordering of a regular expression submatch and a string.
-   * @param lhs A regular expression submatch.
-   * @param rhs A const string reference.
-   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
-   */
-  template<typename _Bi_iter>
-    inline bool
-    operator<=(const sub_match<_Bi_iter>& __lhs,
-	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
-    { return __lhs.str() <= __rhs; }
-
-  /**
-   * @brief Inserts a matched string into an output stream.
-   *
-   * @param os The output stream.
-   * @param m  A submatch string.
-   *
-   * @returns the output stream with the submatch string inserted.
-   */
-  template<typename _Ch_type, typename _Ch_traits, typename _Bi_iter>
-    inline
-    basic_ostream<_Ch_type, _Ch_traits>&
-    operator<<(basic_ostream<_Ch_type, _Ch_traits>& __os,
-	       const sub_match<_Bi_iter>& __m)
-    { return __os << __m.str(); }
-
-  // [7.10] Class template match_results
-  /**
-   * @brief The results of a match or search operation.
-   *
-   * A collection of character sequences representing the result of a regular
-   * expression match.  Storage for the collection is allocated and freed as
-   * necessary by the member functions of class template match_results.
-   *
-   * This class satisfies the Sequence requirements, with the exception that
-   * only the operations defined for a const-qualified Sequence are supported.
-   *
-   * The sub_match object stored at index 0 represents sub-expression 0, i.e.
-   * the whole match. In this case the sub_match member matched is always true.
-   * The sub_match object stored at index n denotes what matched the marked
-   * sub-expression n within the matched expression. If the sub-expression n
-   * participated in a regular expression match then the sub_match member
-   * matched evaluates to true, and members first and second denote the range
-   * of characters [first, second) which formed that match. Otherwise matched
-   * is false, and members first and second point to the end of the sequence
-   * that was searched.
-   *
-   * @nosubgrouping
-   */
-  template<typename _Bi_iter,
-	   typename _Allocator = allocator<sub_match<_Bi_iter> > >
-    class match_results
-    : private std::vector<std::_GLIBCXX_TR1 sub_match<_Bi_iter>, _Allocator>
-    {
-    private:
-      typedef std::vector<std::_GLIBCXX_TR1 sub_match<_Bi_iter>, _Allocator>
-                                                              _Base_type;
-
-    public:
-      /**
-       * @name 10.? Public Types
-       */
-      //@{
-      typedef sub_match<_Bi_iter>                             value_type;
-      typedef typename _Allocator::const_reference            const_reference;
-      typedef const_reference                                 reference;
-      typedef typename _Base_type::const_iterator             const_iterator;
-      typedef const_iterator                                  iterator;
-      typedef typename iterator_traits<_Bi_iter>::difference_type
-                                                              difference_type;
-      typedef typename _Allocator::size_type                  size_type;
-      typedef _Allocator                                      allocator_type;
-      typedef typename iterator_traits<_Bi_iter>::value_type  char_type;
-      typedef basic_string<char_type>                         string_type;
-      //@}
-  
-    public:
-      /**
-       * @name 10.1 Construction, Copying, and Destruction
-       */
-      //@{
-
-      /**
-       * @brief Constructs a default %match_results container.
-       * @post size() returns 0 and str() returns an empty string.
-       */
-      explicit
-      match_results(const _Allocator& __a = _Allocator())
-      : _Base_type(__a), _M_matched(false)
-      { }
-
-      /**
-       * @brief Copy constructs a %match_results.
-       */
-      match_results(const match_results& __rhs)
-      : _Base_type(__rhs), _M_matched(__rhs._M_matched),
-	_M_prefix(__rhs._M_prefix), _M_suffix(__rhs._M_suffix)
-      { }
-
-      /**
-       * @brief Assigns rhs to *this.
-       */
-      match_results&
-      operator=(const match_results& __rhs)
-      {
-	match_results __tmp(__rhs);
-	this->swap(__tmp);
-	return *this;
-      }
-
-      /**
-       * @brief Destroys a %match_results object.
-       */
-      ~match_results()
-      { }
-      
-      //@}
-
-      /**
-       * @name 10.2 Size
-       */
-      //@{
-
-      /**
-       * @brief Gets the number of matches and submatches.
-       *
-       * The number of matches for a given regular expression will be either 0
-       * if there was no match or mark_count() + 1 if a match was successful.
-       * Some matches may be empty.
-       *
-       * @returns the number of matches found.
-       */
-      size_type
-      size() const
-      { return _M_matched ? _Base_type::size() + 1 : 0; }
-      
-      //size_type
-      //max_size() const;
-      using _Base_type::max_size;
-
-      /**
-       * @brief Indicates if the %match_results contains no results.
-       * @retval true The %match_results object is empty.
-       * @retval false The %match_results object is not empty.
-       */
-      bool
-      empty() const
-      { return size() == 0; }
-      
-      //@}
-
-      /**
-       * @name 10.3 Element Access
-       */
-      //@{
-
-      /**
-       * @brief Gets the length of the indicated submatch.
-       * @param sub indicates the submatch.
-       *
-       * This function returns the length of the indicated submatch, or the
-       * length of the entire match if @p sub is zero (the default).
-       */
-      difference_type
-      length(size_type __sub = 0) const
-      { return _M_matched ? this->str(__sub).length() : 0; }
-
-      /**
-       * @brief Gets the offset of the beginning of the indicated submatch.
-       * @param sub indicates the submatch.
-       *
-       * This function returns the offset from the beginning of the target
-       * sequence to the beginning of the submatch, unless the value of @p sub
-       * is zero (the default), in which case this function returns the offset
-       * from the beginning of the target sequence to the beginning of the
-       * match.
-       */
-      difference_type
-      position(size_type __sub = 0) const
-      {
-	return _M_matched ? std::distance(this->prefix().first,
-					  (*this)[__sub].first) : 0;
-      }
-
-      /**
-       * @brief Gets the match or submatch converted to a string type.
-       * @param sub indicates the submatch.
-       *
-       * This function gets the submatch (or match, if @p sub is zero) extracted
-       * from the target range and converted to the associated string type.
-       */
-      string_type
-      str(size_type __sub = 0) const
-      { return _M_matched ? (*this)[__sub].str() : string_type(); }
-      
-      /**
-       * @brief Gets a %sub_match reference for the match or submatch.
-       * @param sub indicates the submatch.
-       *
-       * This function gets a reference to the indicated submatch, or the entire
-       * match if @p sub is zero.
-       *
-       * If @p sub >= size() then this function returns a %sub_match with a
-       * special value indicating no submatch.
-       */
-      const_reference
-      operator[](size_type __sub) const
-      { return _Base_type::operator[](__sub); }
-
-      /**
-       * @brief Gets a %sub_match representing the match prefix.
-       *
-       * This function gets a reference to a %sub_match object representing the
-       * part of the target range between the start of the target range and the
-       * start of the match.
-       */
-      const_reference
-      prefix() const
-      { return _M_prefix; }
-
-      /**
-       * @brief Gets a %sub_match representing the match suffix.
-       *
-       * This function gets a reference to a %sub_match object representing the
-       * part of the target range between the end of the match and the end of
-       * the target range.
-       */
-      const_reference
-      suffix() const
-      { return _M_suffix; }
-
-      /**
-       * @brief Gets an iterator to the start of the %sub_match collection.
-       */
-      const_iterator
-      begin() const
-      { return _Base_type::begin(); }
-      
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      /**
-       * @brief Gets an iterator to the start of the %sub_match collection.
-       */
-      const_iterator
-      cbegin() const
-      { return _Base_type::begin(); }
-#endif
-
-      /**
-       * @brief Gets an iterator to one-past-the-end of the collection.
-       */
-      const_iterator
-      end() const
-      { return _Base_type::end(); }
-      
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      /**
-       * @brief Gets an iterator to one-past-the-end of the collection.
-       */
-      const_iterator
-      cend() const
-      { return _Base_type::end(); }
-#endif
-
-      //@}
-
-      /**
-       * @name 10.4 Formatting
-       *
-       * These functions perform formatted substitution of the matched character
-       * sequences into their target.  The format specifiers and escape sequences
-       * accepted by these functions are determined by their @p flags parameter 
-       * as documented above.
-       */
-       //@{
-
-      /**
-       * @todo Implement this function.
-       */
-      template<typename _Out_iter>
-        _Out_iter
-        format(_Out_iter __out, const string_type& __fmt,
-	       regex_constants::match_flag_type __flags
-	       = regex_constants::format_default) const;
-
-      /**
-       * @todo Implement this function.
-       */
-      string_type
-      format(const string_type& __fmt,
-	     regex_constants::match_flag_type __flags
-	     = regex_constants::format_default) const;
-
-      //@} 
-
-      /**
-       * @name 10.5 Allocator
-       */
-      //@{ 
-
-      /**
-       * @brief Gets a copy of the allocator.
-       */
-      //allocator_type
-      //get_allocator() const;
-      using _Base_type::get_allocator;
-      
-      //@} 
-
-      /**
-       * @name 10.6 Swap
-       */
-       //@{ 
-
-      /**
-       * @brief Swaps the contents of two match_results.
-       */
-      void
-      swap(match_results& __that)
-      {
-	_Base_type::swap(__that);
-	std::swap(_M_matched, __that._M_matched);
-	std::swap(_M_prefix,  __that._M_prefix);
-	std::swap(_M_suffix,  __that._M_suffix);
-      }
-      //@} 
-      
-    private:
-      bool       _M_matched;
-      value_type _M_prefix;
-      value_type _M_suffix;
-    };
-  
-  typedef match_results<const char*>             cmatch;
-  typedef match_results<string::const_iterator>  smatch;
-#ifdef _GLIBCXX_USE_WCHAR_T
-  typedef match_results<const wchar_t*>          wcmatch;
-  typedef match_results<wstring::const_iterator> wsmatch;
-#endif
-
-  // match_results comparisons
-  /**
-   * @brief Compares two match_results for equality.
-   * @returns true if the two objects refer to the same match,
-   * false otherwise.
-   * @todo Implement this function.
-   */
-  template<typename _Bi_iter, typename _Allocator>
-    inline bool
-    operator==(const match_results<_Bi_iter, _Allocator>& __m1,
-	       const match_results<_Bi_iter, _Allocator>& __m2);
-
-  /**
-   * @brief Compares two match_results for inequality.
-   * @returns true if the two objects do not refer to the same match,
-   * false otherwise.
-   */
-  template<typename _Bi_iter, class _Allocator>
-    inline bool
-    operator!=(const match_results<_Bi_iter, _Allocator>& __m1,
-	       const match_results<_Bi_iter, _Allocator>& __m2)
-    { return !(__m1 == __m2); }
-
-  // [7.10.6] match_results swap
-  /**
-   * @brief Swaps two match results.
-   * @param lhs A match result.
-   * @param rhs A match result.
-   *
-   * The contents of the two match_results objects are swapped.
-   */
-  template<typename _Bi_iter, typename _Allocator>
-    inline void
-    swap(match_results<_Bi_iter, _Allocator>& __lhs,
-	 match_results<_Bi_iter, _Allocator>& __rhs)
-    { __lhs.swap(__rhs); }
-
-  // [7.11.2] Function template regex_match
-  /**
-   * @name Matching, Searching, and Replacing
-   */
-  //@{
-
-  /**
-   * @brief Determines if there is a match between the regular expression @p e
-   * and all of the character sequence [first, last).
-   *
-   * @param first Beginning of the character sequence to match.
-   * @param last  One-past-the-end of the character sequence to match.
-   * @param m     The match results.
-   * @param re    The regular expression.
-   * @param flags Controls how the regular expression is matched.
-   *
-   * @retval true  A match exists.
-   * @retval false Otherwise.
-   *
-   * @throws an exception of type regex_error.
-   *
-   * @todo Implement this function.
-   */
-  template<typename _Bi_iter, typename _Allocator,
-	   typename _Ch_type, typename _Rx_traits>
-    bool
-    regex_match(_Bi_iter __first, _Bi_iter __last,
-		match_results<_Bi_iter, _Allocator>& __m,
-		const basic_regex<_Ch_type, _Rx_traits>& __re,
-		regex_constants::match_flag_type __flags
-		= regex_constants::match_default);
-
-  /**
-   * @brief Indicates if there is a match between the regular expression @p e
-   * and all of the character sequence [first, last).
-   *
-   * @param first Beginning of the character sequence to match.
-   * @param last  One-past-the-end of the character sequence to match.
-   * @param re    The regular expression.
-   * @param flags Controls how the regular expression is matched.
-   *
-   * @retval true  A match exists.
-   * @retval false Otherwise.
-   *
-   * @throws an exception of type regex_error.
-   */
-  template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
-    bool
-    regex_match(_Bi_iter __first, _Bi_iter __last,
-		const basic_regex<_Ch_type, _Rx_traits>& __re,
-		regex_constants::match_flag_type __flags
-		= regex_constants::match_default)
-    { 
-      match_results<_Bi_iter> __what;
-      return regex_match(__first, __last, __what, __re, __flags);
-    }
-
-  /**
-   * @brief Determines if there is a match between the regular expression @p e
-   * and a C-style null-terminated string.
-   *
-   * @param s  The C-style null-terminated string to match.
-   * @param m  The match results.
-   * @param re The regular expression.
-   * @param f  Controls how the regular expression is matched.
-   *
-   * @retval true  A match exists.
-   * @retval false Otherwise.
-   *
-   * @throws an exception of type regex_error.
-   */
-  template<typename _Ch_type, typename _Allocator, typename _Rx_traits>
-    inline bool
-    regex_match(const _Ch_type* __s,
-		match_results<const _Ch_type*, _Allocator>& __m,
-		const basic_regex<_Ch_type, _Rx_traits>& __re,
-		regex_constants::match_flag_type __f
-		= regex_constants::match_default)
-    { return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); }
-
-  /**
-   * @brief Determines if there is a match between the regular expression @p e
-   * and a string.
-   *
-   * @param s     The string to match.
-   * @param m     The match results.
-   * @param re    The regular expression.
-   * @param flags Controls how the regular expression is matched.
-   *
-   * @retval true  A match exists.
-   * @retval false Otherwise.
-   *
-   * @throws an exception of type regex_error.
-   */
-  template<typename _Ch_traits, typename _Ch_alloc,
-	   typename _Allocator, typename _Ch_type, typename _Rx_traits>
-    inline bool
-    regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
-		match_results<typename basic_string<_Ch_type, 
-		_Ch_traits, _Ch_alloc>::const_iterator, _Allocator>& __m,
-		const basic_regex<_Ch_type, _Rx_traits>& __re,
-		regex_constants::match_flag_type __flags
-		= regex_constants::match_default)
-    { return regex_match(__s.begin(), __s.end(), __m, __re, __flags); }
-
-  /**
-   * @brief Indicates if there is a match between the regular expression @p e
-   * and a C-style null-terminated string.
-   *
-   * @param s  The C-style null-terminated string to match.
-   * @param re The regular expression.
-   * @param f  Controls how the regular expression is matched.
-   *
-   * @retval true  A match exists.
-   * @retval false Otherwise.
-   *
-   * @throws an exception of type regex_error.
-   */
-  template<typename _Ch_type, class _Rx_traits>
-    inline bool
-    regex_match(const _Ch_type* __s,
-		const basic_regex<_Ch_type, _Rx_traits>& __re,
-		regex_constants::match_flag_type __f
-		= regex_constants::match_default)
-    { return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); }
-
-  /**
-   * @brief Indicates if there is a match between the regular expression @p e
-   * and a string.
-   *
-   * @param s     [IN] The string to match.
-   * @param re    [IN] The regular expression.
-   * @param flags [IN] Controls how the regular expression is matched.
-   *
-   * @retval true  A match exists.
-   * @retval false Otherwise.
-   *
-   * @throws an exception of type regex_error.
-   */
-  template<typename _Ch_traits, typename _Str_allocator,
-	   typename _Ch_type, typename _Rx_traits>
-    inline bool
-    regex_match(const basic_string<_Ch_type, _Ch_traits, _Str_allocator>& __s,
-		const basic_regex<_Ch_type, _Rx_traits>& __re,
-		regex_constants::match_flag_type __flags
-		= regex_constants::match_default)
-    { return regex_match(__s.begin(), __s.end(), __re, __flags); }
-
-  // [7.11.3] Function template regex_search
-  /**
-   * Searches for a regular expression within a range.
-   * @param first [IN]  The start of the string to search.
-   * @param last  [IN]  One-past-the-end of the string to search.
-   * @param m     [OUT] The match results.
-   * @param re    [IN]  The regular expression to search for.
-   * @param flags [IN]  Search policy flags.
-   * @retval true  A match was found within the string.
-   * @retval false No match was found within the string, the content of %m is
-   *               undefined.
-   *
-   * @throws an exception of type regex_error.
-   *
-   * @todo Implement this function.
-   */
-  template<typename _Bi_iter, typename _Allocator,
-	   typename _Ch_type, typename _Rx_traits>
-    inline bool
-    regex_search(_Bi_iter __first, _Bi_iter __last,
-		 match_results<_Bi_iter, _Allocator>& __m,
-		 const basic_regex<_Ch_type, _Rx_traits>& __re,
-		 regex_constants::match_flag_type __flags
-		 = regex_constants::match_default);
-
-  /**
-   * Searches for a regular expression within a range.
-   * @param first [IN]  The start of the string to search.
-   * @param last  [IN]  One-past-the-end of the string to search.
-   * @param re    [IN]  The regular expression to search for.
-   * @param flags [IN]  Search policy flags.
-   * @retval true  A match was found within the string.
-   * @retval false No match was found within the string.
-   * @doctodo
-   *
-   * @throws an exception of type regex_error.
-   */
-  template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
-    inline bool
-    regex_search(_Bi_iter __first, _Bi_iter __last,
-		 const basic_regex<_Ch_type, _Rx_traits>& __re,
-		 regex_constants::match_flag_type __flags
-		 = regex_constants::match_default)
-    {
-      match_results<_Bi_iter> __what;
-      return regex_search(__first, __last, __what, __re, __flags);
-    }
-
-  /**
-   * @brief Searches for a regular expression within a C-string.
-   * @param s [IN]  A C-string to search for the regex.
-   * @param m [OUT] The set of regex matches.
-   * @param e [IN]  The regex to search for in @p s.
-   * @param f [IN]  The search flags.
-   * @retval true  A match was found within the string.
-   * @retval false No match was found within the string, the content of %m is
-   *               undefined.
-   * @doctodo
-   *
-   * @throws an exception of type regex_error.
-   */
-  template<typename _Ch_type, class _Allocator, class _Rx_traits>
-    inline bool
-    regex_search(const _Ch_type* __s,
-		 match_results<const _Ch_type*, _Allocator>& __m,
-		 const basic_regex<_Ch_type, _Rx_traits>& __e,
-		 regex_constants::match_flag_type __f
-		 = regex_constants::match_default)
-    { return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); }
-
-  /**
-   * @brief Searches for a regular expression within a C-string.
-   * @param s [IN]  The C-string to search.
-   * @param e [IN]  The regular expression to search for.
-   * @param f [IN]  Search policy flags.
-   * @retval true  A match was found within the string.
-   * @retval false No match was found within the string.
-   * @doctodo
-   *
-   * @throws an exception of type regex_error.
-   */
-  template<typename _Ch_type, typename _Rx_traits>
-    inline bool
-    regex_search(const _Ch_type* __s,
-		 const basic_regex<_Ch_type, _Rx_traits>& __e,
-		 regex_constants::match_flag_type __f
-		 = regex_constants::match_default)
-    { return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); }
-
-  /**
-   * @brief Searches for a regular expression within a string.
-   * @param s     [IN]  The string to search.
-   * @param e     [IN]  The regular expression to search for.
-   * @param flags [IN]  Search policy flags.
-   * @retval true  A match was found within the string.
-   * @retval false No match was found within the string.
-   * @doctodo
-   *
-   * @throws an exception of type regex_error.
-   */
-  template<typename _Ch_traits, typename _String_allocator,
-	   typename _Ch_type, typename _Rx_traits>
-    inline bool
-    regex_search(const basic_string<_Ch_type, _Ch_traits,
-		 _String_allocator>& __s,
-		 const basic_regex<_Ch_type, _Rx_traits>& __e,
-		 regex_constants::match_flag_type __flags
-		 = regex_constants::match_default)
-    { return regex_search(__s.begin(), __s.end(), __e, __flags); }
-
-  /**
-   * @brief Searches for a regular expression within a string.
-   * @param s [IN]  A C++ string to search for the regex.
-   * @param m [OUT] The set of regex matches.
-   * @param e [IN]  The regex to search for in @p s.
-   * @param f [IN]  The search flags.
-   * @retval true  A match was found within the string.
-   * @retval false No match was found within the string, the content of %m is
-   *               undefined.
-   *
-   * @throws an exception of type regex_error.
-   */
-  template<typename _Ch_traits, typename _Ch_alloc,
-	   typename _Allocator, typename _Ch_type,
-	   typename _Rx_traits>
-    inline bool
-    regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
-		 match_results<typename basic_string<_Ch_type,
-		 _Ch_traits, _Ch_alloc>::const_iterator, _Allocator>& __m,
-		 const basic_regex<_Ch_type, _Rx_traits>& __e,
-		 regex_constants::match_flag_type __f
-		 = regex_constants::match_default)
-    { return regex_search(__s.begin(), __s.end(), __m, __e, __f); }
-
-  // tr1 [7.11.4] std [28.11.4] Function template regex_replace
-  /**
-   * @doctodo
-   * @param out
-   * @param first
-   * @param last
-   * @param e
-   * @param fmt
-   * @param flags
-   *
-   * @returns out
-   * @throws an exception of type regex_error.
-   *
-   * @todo Implement this function.
-   */
-  template<typename _Out_iter, typename _Bi_iter,
-	   typename _Rx_traits, typename _Ch_type>
-    inline _Out_iter
-    regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
-		  const basic_regex<_Ch_type, _Rx_traits>& __e,
-		  const basic_string<_Ch_type>& __fmt,
-		  regex_constants::match_flag_type __flags
-		  = regex_constants::match_default);
-
-  /**
-   * @doctodo
-   * @param s
-   * @param e
-   * @param fmt
-   * @param flags
-   *
-   * @returns a copy of string @p s with replacements.
-   *
-   * @throws an exception of type regex_error.
-   */
-  template<typename _Rx_traits, typename _Ch_type>
-    inline basic_string<_Ch_type>
-    regex_replace(const basic_string<_Ch_type>& __s,
-		  const basic_regex<_Ch_type, _Rx_traits>& __e,
-		  const basic_string<_Ch_type>& __fmt,
-		  regex_constants::match_flag_type __flags
-		  = regex_constants::match_default)
-    {
-      std::string __result;
-      regex_replace(std::back_inserter(__result),
-		    __s.begin(), __s.end(), __e, __fmt, __flags);
-      return __result;
-    }
-
-  //@}
-
-  // tr1 [7.12.1] std [28.12] Class template regex_iterator
-  /**
-   * An iterator adaptor that will provide repeated calls of regex_search over 
-   * a range until no more matches remain.
-   */
-  template<typename _Bi_iter,
-	   typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
-	   typename _Rx_traits = regex_traits<_Ch_type> >
-    class regex_iterator
-    {
-    public:
-      typedef basic_regex<_Ch_type, _Rx_traits>  regex_type;
-      typedef match_results<_Bi_iter>            value_type;
-      typedef std::ptrdiff_t                     difference_type;
-      typedef const value_type*                  pointer;
-      typedef const value_type&                  reference;
-      typedef std::forward_iterator_tag          iterator_category;
-
-    public:
-      /**
-       * @brief Provides a singular iterator, useful for indicating
-       * one-past-the-end of a range.
-       * @todo Implement this function.
-       * @doctodo
-       */
-      regex_iterator();
-      
-      /**
-       * Constructs a %regex_iterator...
-       * @param a  [IN] The start of a text range to search.
-       * @param b  [IN] One-past-the-end of the text range to search.
-       * @param re [IN] The regular expression to match.
-       * @param m  [IN] Policy flags for match rules.
-       * @todo Implement this function.
-       * @doctodo
-       */
-      regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
-		     regex_constants::match_flag_type __m
-		     = regex_constants::match_default);
-
-      /**
-       * Copy constructs a %regex_iterator.
-       * @todo Implement this function.
-       * @doctodo
-       */
-      regex_iterator(const regex_iterator& __rhs);
-      
-      /**
-       * @todo Implement this function.
-       * @doctodo
-       */
-      regex_iterator&
-      operator=(const regex_iterator& __rhs);
-      
-      /**
-       * @todo Implement this function.
-       * @doctodo
-       */
-      bool
-      operator==(const regex_iterator& __rhs);
-      
-      /**
-       * @todo Implement this function.
-       * @doctodo
-       */
-      bool
-      operator!=(const regex_iterator& __rhs);
-      
-      /**
-       * @todo Implement this function.
-       * @doctodo
-       */
-      const value_type&
-      operator*();
-      
-      /**
-       * @todo Implement this function.
-       * @doctodo
-       */
-      const value_type*
-      operator->();
-      
-      /**
-       * @todo Implement this function.
-       * @doctodo
-       */
-      regex_iterator&
-      operator++();
-      
-      /**
-       * @todo Implement this function.
-       * @doctodo
-       */
-      regex_iterator
-      operator++(int);
-      
-    private:
-      // these members are shown for exposition only:
-      _Bi_iter                         begin;
-      _Bi_iter                         end;
-      const regex_type*                pregex;
-      regex_constants::match_flag_type flags;
-      match_results<_Bi_iter>          match;
-    };
-  
-  typedef regex_iterator<const char*>             cregex_iterator;
-  typedef regex_iterator<string::const_iterator>  sregex_iterator;
-#ifdef _GLIBCXX_USE_WCHAR_T
-  typedef regex_iterator<const wchar_t*>          wcregex_iterator;
-  typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
-#endif
-
-  // [7.12.2] Class template regex_token_iterator
-  /**
-   * Iterates over submatches in a range (or "splits" a text string).
-   *
-   * The purpose of this iterator is to enumerate all, or all specified,
-   * matches of a regular expression within a text range.  The dereferenced
-   * value of an iterator of this class is a std::tr1::sub_match object.
-   */
-  template<typename _Bi_iter,
-	   typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
-	   typename _Rx_traits = regex_traits<_Ch_type> >
-    class regex_token_iterator
-    {
-    public:
-      typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
-      typedef sub_match<_Bi_iter>               value_type;
-      typedef std::ptrdiff_t                    difference_type;
-      typedef const value_type*                 pointer;
-      typedef const value_type&                 reference;
-      typedef std::forward_iterator_tag         iterator_category;
-      
-    public:
-      /**
-       * @brief Default constructs a %regex_token_iterator.
-       * @todo Implement this function.
-       * 
-       * A default-constructed %regex_token_iterator is a singular iterator
-       * that will compare equal to the one-past-the-end value for any
-       * iterator of the same type.
-       */
-      regex_token_iterator();
-      
-      /**
-       * Constructs a %regex_token_iterator...
-       * @param a          [IN] The start of the text to search.
-       * @param b          [IN] One-past-the-end of the text to search.
-       * @param re         [IN] The regular expression to search for.
-       * @param submatch   [IN] Which submatch to return.  There are some
-       *                        special values for this parameter:
-       *                        - -1 each enumerated subexpression does NOT
-       *                          match the regular expression (aka field
-       *                          splitting)
-       *                        - 0 the entire string matching the
-       *                          subexpression is returned for each match
-       *                          within the text.
-       *                        - >0 enumerates only the indicated
-       *                          subexpression from a match within the text.
-       * @param m          [IN] Policy flags for match rules.
-       *
-       * @todo Implement this function.
-       * @doctodo
-       */
-      regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
-			   int __submatch = 0,
-			   regex_constants::match_flag_type __m
-			   = regex_constants::match_default);
-
-      /**
-       * Constructs a %regex_token_iterator...
-       * @param a          [IN] The start of the text to search.
-       * @param b          [IN] One-past-the-end of the text to search.
-       * @param re         [IN] The regular expression to search for.
-       * @param submatches [IN] A list of subexpressions to return for each
-       *                        regular expression match within the text.
-       * @param m          [IN] Policy flags for match rules.
-       *
-       * @todo Implement this function.
-       * @doctodo
-       */
-      regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
-			   const regex_type& __re,
-			   const std::vector<int>& __submatches,
-			   regex_constants::match_flag_type __m
-			     = regex_constants::match_default);
-
-      /**
-       * Constructs a %regex_token_iterator...
-       * @param a          [IN] The start of the text to search.
-       * @param b          [IN] One-past-the-end of the text to search.
-       * @param re         [IN] The regular expression to search for.
-       * @param submatches [IN] A list of subexpressions to return for each
-       *                        regular expression match within the text.
-       * @param m          [IN] Policy flags for match rules.
-       
-       * @todo Implement this function.
-       * @doctodo
-       */
-      template<std::size_t _Nm>
-        regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
-			     const regex_type& __re,
-			     const int (&__submatches)[_Nm],
-			     regex_constants::match_flag_type __m
-			     = regex_constants::match_default);
-
-      /**
-       * @brief Copy constructs a %regex_token_iterator.
-       * @param rhs [IN] A %regex_token_iterator to copy.
-       * @todo Implement this function.
-       */
-      regex_token_iterator(const regex_token_iterator& __rhs);
-      
-      /**
-       * @brief Assigns a %regex_token_iterator to another.
-       * @param rhs [IN] A %regex_token_iterator to copy.
-       * @todo Implement this function.
-       */
-      regex_token_iterator&
-      operator=(const regex_token_iterator& __rhs);
-      
-      /**
-       * @brief Compares a %regex_token_iterator to another for equality.
-       * @todo Implement this function.
-       */
-      bool
-      operator==(const regex_token_iterator& __rhs);
-      
-      /**
-       * @brief Compares a %regex_token_iterator to another for inequality.
-       * @todo Implement this function.
-       */
-      bool
-      operator!=(const regex_token_iterator& __rhs);
-      
-      /**
-       * @brief Dereferences a %regex_token_iterator.
-       * @todo Implement this function.
-       */
-      const value_type&
-      operator*();
-      
-      /**
-       * @brief Selects a %regex_token_iterator member.
-       * @todo Implement this function.
-       */
-      const value_type*
-      operator->();
-      
-      /**
-       * @brief Increments a %regex_token_iterator.
-       * @todo Implement this function.
-       */
-      regex_token_iterator&
-      operator++();
-      
-      /**
-       * @brief Postincrements a %regex_token_iterator.
-       * @todo Implement this function.
-       */
-      regex_token_iterator
-      operator++(int);
-      
-    private: // data members for exposition only:
-      typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> position_iterator;
-
-      position_iterator __position;
-      const value_type* __result;
-      value_type        __suffix;
-      std::size_t       __n;
-      std::vector<int>  __subs;
-    };
-
-  /** @brief Token iterator for C-style NULL-terminated strings. */
-  typedef regex_token_iterator<const char*>             cregex_token_iterator;
-  /** @brief Token iterator for standard strings. */
-  typedef regex_token_iterator<string::const_iterator>  sregex_token_iterator;
-#ifdef _GLIBCXX_USE_WCHAR_T
-  /** @brief Token iterator for C-style NULL-terminated wide strings. */
-  typedef regex_token_iterator<const wchar_t*>          wcregex_token_iterator;
-  /** @brief Token iterator for standard wide-character strings. */
-  typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
-#endif
-  
-  //@} 
-  
-_GLIBCXX_END_NAMESPACE_TR1
-}
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/type_traits b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/type_traits
deleted file mode 100644
index 75b85ea2f..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/type_traits
+++ /dev/null
@@ -1,501 +0,0 @@
-// TR1 type_traits -*- C++ -*-
-
-// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/type_traits
-*  This is an internal header file, included by other library headers.
-*  You should not attempt to use it directly.
-*/
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-  /**
-   * @defgroup metaprogramming Type Traits
-   * @ingroup utilities
-   *
-   * Compile time type transformation and information.
-   * @{
-   */
-
-  // For use in __is_convertible_simple.
-  struct __sfinae_types
-  {
-    typedef char __one;
-    typedef struct { char __arr[2]; } __two;
-  };
-
-#define _DEFINE_SPEC_0_HELPER                          \
-  template<>
-
-#define _DEFINE_SPEC_1_HELPER                          \
-  template<typename _Tp>
-
-#define _DEFINE_SPEC_2_HELPER                          \
-  template<typename _Tp, typename _Cp>
-
-#define _DEFINE_SPEC(_Order, _Trait, _Type, _Value)    \
-  _DEFINE_SPEC_##_Order##_HELPER                       \
-    struct _Trait<_Type>                               \
-    : public integral_constant<bool, _Value> { };
-
-  // helper classes [4.3].
-
-  /// integral_constant
-  template<typename _Tp, _Tp __v>
-    struct integral_constant
-    {
-      static const _Tp                      value = __v;
-      typedef _Tp                           value_type;
-      typedef integral_constant<_Tp, __v>   type;
-    };
-  
-  /// typedef for true_type
-  typedef integral_constant<bool, true>     true_type;
-
-  /// typedef for false_type
-  typedef integral_constant<bool, false>    false_type;
-
-  template<typename _Tp, _Tp __v>
-    const _Tp integral_constant<_Tp, __v>::value;
-
-  /// remove_cv
-  template<typename>
-    struct remove_cv;
-
-  template<typename>
-    struct __is_void_helper
-    : public false_type { };
-  _DEFINE_SPEC(0, __is_void_helper, void, true)
-
-  // primary type categories [4.5.1].
-
-  /// is_void
-  template<typename _Tp>
-    struct is_void
-    : public integral_constant<bool, (__is_void_helper<typename
-				      remove_cv<_Tp>::type>::value)>
-    { };
-
-  template<typename>
-    struct __is_integral_helper
-    : public false_type { };
-  _DEFINE_SPEC(0, __is_integral_helper, bool, true)
-  _DEFINE_SPEC(0, __is_integral_helper, char, true)
-  _DEFINE_SPEC(0, __is_integral_helper, signed char, true)
-  _DEFINE_SPEC(0, __is_integral_helper, unsigned char, true)
-#ifdef _GLIBCXX_USE_WCHAR_T
-  _DEFINE_SPEC(0, __is_integral_helper, wchar_t, true)
-#endif
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-  _DEFINE_SPEC(0, __is_integral_helper, char16_t, true)
-  _DEFINE_SPEC(0, __is_integral_helper, char32_t, true)
-#endif
-  _DEFINE_SPEC(0, __is_integral_helper, short, true)
-  _DEFINE_SPEC(0, __is_integral_helper, unsigned short, true)
-  _DEFINE_SPEC(0, __is_integral_helper, int, true)
-  _DEFINE_SPEC(0, __is_integral_helper, unsigned int, true)
-  _DEFINE_SPEC(0, __is_integral_helper, long, true)
-  _DEFINE_SPEC(0, __is_integral_helper, unsigned long, true)
-  _DEFINE_SPEC(0, __is_integral_helper, long long, true)
-  _DEFINE_SPEC(0, __is_integral_helper, unsigned long long, true)
-
-  /// is_integral
-  template<typename _Tp>
-    struct is_integral
-    : public integral_constant<bool, (__is_integral_helper<typename
-				      remove_cv<_Tp>::type>::value)>
-    { };
-
-  template<typename>
-    struct __is_floating_point_helper
-    : public false_type { };
-  _DEFINE_SPEC(0, __is_floating_point_helper, float, true)
-  _DEFINE_SPEC(0, __is_floating_point_helper, double, true)
-  _DEFINE_SPEC(0, __is_floating_point_helper, long double, true)
-
-  /// is_floating_point
-  template<typename _Tp>
-    struct is_floating_point
-    : public integral_constant<bool, (__is_floating_point_helper<typename
-				      remove_cv<_Tp>::type>::value)>
-    { };
-
-  /// is_array
-  template<typename>
-    struct is_array
-    : public false_type { };
-
-  template<typename _Tp, std::size_t _Size>
-    struct is_array<_Tp[_Size]>
-    : public true_type { };
-
-  template<typename _Tp>
-    struct is_array<_Tp[]>
-    : public true_type { };
-
-  template<typename>
-    struct __is_pointer_helper
-    : public false_type { };
-  _DEFINE_SPEC(1, __is_pointer_helper, _Tp*, true)
-
-  /// is_pointer
-  template<typename _Tp>
-    struct is_pointer
-    : public integral_constant<bool, (__is_pointer_helper<typename
-				      remove_cv<_Tp>::type>::value)>
-    { };
-
-  /// is_reference
-  template<typename _Tp>
-    struct is_reference;
-
-  /// is_function
-  template<typename _Tp>
-    struct is_function;
-
-  template<typename>
-    struct __is_member_object_pointer_helper
-    : public false_type { };
-  _DEFINE_SPEC(2, __is_member_object_pointer_helper, _Tp _Cp::*,
-	       !is_function<_Tp>::value)
-
-  /// is_member_object_pointer
-  template<typename _Tp>
-    struct is_member_object_pointer
-    : public integral_constant<bool, (__is_member_object_pointer_helper<
-				      typename remove_cv<_Tp>::type>::value)>
-    { };
-
-  template<typename>
-    struct __is_member_function_pointer_helper
-    : public false_type { };
-  _DEFINE_SPEC(2, __is_member_function_pointer_helper, _Tp _Cp::*,
-	       is_function<_Tp>::value)
-
-  /// is_member_function_pointer
-  template<typename _Tp>
-    struct is_member_function_pointer
-    : public integral_constant<bool, (__is_member_function_pointer_helper<
-				      typename remove_cv<_Tp>::type>::value)>
-    { };
-
-  /// is_enum
-  template<typename _Tp>
-    struct is_enum
-    : public integral_constant<bool, __is_enum(_Tp)>
-    { };
-
-  /// is_union
-  template<typename _Tp>
-    struct is_union
-    : public integral_constant<bool, __is_union(_Tp)>
-    { };
-
-  /// is_class
-  template<typename _Tp>
-    struct is_class
-    : public integral_constant<bool, __is_class(_Tp)>
-    { };
-
-  /// is_function
-  template<typename>
-    struct is_function
-    : public false_type { };
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes...)>
-    : public true_type { };
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes......)>
-    : public true_type { };
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes...) const>
-    : public true_type { };
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes......) const>
-    : public true_type { };
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes...) volatile>
-    : public true_type { };
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes......) volatile>
-    : public true_type { };
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes...) const volatile>
-    : public true_type { };
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes......) const volatile>
-    : public true_type { };
-
-  // composite type traits [4.5.2].
-  
-  /// is_arithmetic
-  template<typename _Tp>
-    struct is_arithmetic
-    : public integral_constant<bool, (is_integral<_Tp>::value
-				      || is_floating_point<_Tp>::value)>
-    { };
-
-  /// is_fundamental
-  template<typename _Tp>
-    struct is_fundamental
-    : public integral_constant<bool, (is_arithmetic<_Tp>::value
-				      || is_void<_Tp>::value)>
-    { };
-
-  /// is_object
-  template<typename _Tp>
-    struct is_object
-    : public integral_constant<bool, !(is_function<_Tp>::value
-				       || is_reference<_Tp>::value
-				       || is_void<_Tp>::value)>
-    { };
-
-  /// is_member_pointer
-  template<typename _Tp>
-    struct is_member_pointer;
-
-  /// is_scalar
-  template<typename _Tp>
-    struct is_scalar
-    : public integral_constant<bool, (is_arithmetic<_Tp>::value
-				      || is_enum<_Tp>::value
-				      || is_pointer<_Tp>::value
-				      || is_member_pointer<_Tp>::value)>
-    { };
-
-  /// is_compound
-  template<typename _Tp>
-    struct is_compound
-    : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
-
-  /// is_member_pointer
-  template<typename _Tp>
-    struct __is_member_pointer_helper
-    : public false_type { };
-  _DEFINE_SPEC(2, __is_member_pointer_helper, _Tp _Cp::*, true)
-
-  template<typename _Tp>
-  struct is_member_pointer
-    : public integral_constant<bool, (__is_member_pointer_helper<
-				      typename remove_cv<_Tp>::type>::value)>
-    { };
-
-  // type properties [4.5.3].
-  /// is_const
-  template<typename>
-    struct is_const
-    : public false_type { };
-
-  template<typename _Tp>
-    struct is_const<_Tp const>
-    : public true_type { };
-  
-  /// is_volatile
-  template<typename>
-    struct is_volatile
-    : public false_type { };
-
-  template<typename _Tp>
-    struct is_volatile<_Tp volatile>
-    : public true_type { };
-
-  /// is_empty
-  template<typename _Tp>
-    struct is_empty
-    : public integral_constant<bool, __is_empty(_Tp)>
-    { };
-
-  /// is_polymorphic
-  template<typename _Tp>
-    struct is_polymorphic
-    : public integral_constant<bool, __is_polymorphic(_Tp)>
-    { };
-
-  /// is_abstract
-  template<typename _Tp>
-    struct is_abstract
-    : public integral_constant<bool, __is_abstract(_Tp)>
-    { };
-
-  /// has_virtual_destructor
-  template<typename _Tp>
-    struct has_virtual_destructor
-    : public integral_constant<bool, __has_virtual_destructor(_Tp)>
-    { };
-
-  /// alignment_of
-  template<typename _Tp>
-    struct alignment_of
-    : public integral_constant<std::size_t, __alignof__(_Tp)> { };
-  
-  /// rank
-  template<typename>
-    struct rank
-    : public integral_constant<std::size_t, 0> { };
-   
-  template<typename _Tp, std::size_t _Size>
-    struct rank<_Tp[_Size]>
-    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
-
-  template<typename _Tp>
-    struct rank<_Tp[]>
-    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
-
-  /// extent
-  template<typename, unsigned _Uint = 0>
-    struct extent
-    : public integral_constant<std::size_t, 0> { };
-  
-  template<typename _Tp, unsigned _Uint, std::size_t _Size>
-    struct extent<_Tp[_Size], _Uint>
-    : public integral_constant<std::size_t,
-			       _Uint == 0 ? _Size : extent<_Tp,
-							   _Uint - 1>::value>
-    { };
-
-  template<typename _Tp, unsigned _Uint>
-    struct extent<_Tp[], _Uint>
-    : public integral_constant<std::size_t,
-			       _Uint == 0 ? 0 : extent<_Tp,
-						       _Uint - 1>::value>
-    { };
-
-  // relationships between types [4.6].
-
-  /// is_same
-  template<typename, typename>
-    struct is_same
-    : public false_type { };
-
-  template<typename _Tp>
-    struct is_same<_Tp, _Tp>
-    : public true_type { };
-
-  // const-volatile modifications [4.7.1].
-
-  /// remove_const
-  template<typename _Tp>
-    struct remove_const
-    { typedef _Tp     type; };
-
-  template<typename _Tp>
-    struct remove_const<_Tp const>
-    { typedef _Tp     type; };
-  
-  /// remove_volatile
-  template<typename _Tp>
-    struct remove_volatile
-    { typedef _Tp     type; };
-
-  template<typename _Tp>
-    struct remove_volatile<_Tp volatile>
-    { typedef _Tp     type; };
-  
-  /// remove_cv
-  template<typename _Tp>
-    struct remove_cv
-    {
-      typedef typename
-      remove_const<typename remove_volatile<_Tp>::type>::type     type;
-    };
-  
-  /// add_const
-  template<typename _Tp>
-    struct add_const
-    { typedef _Tp const     type; };
-   
-  /// add_volatile
-  template<typename _Tp>
-    struct add_volatile
-    { typedef _Tp volatile     type; };
-  
-  /// add_cv
-  template<typename _Tp>
-    struct add_cv
-    {
-      typedef typename
-      add_const<typename add_volatile<_Tp>::type>::type     type;
-    };
-
-  // array modifications [4.7.3].
-
-  /// remove_extent
-  template<typename _Tp>
-    struct remove_extent
-    { typedef _Tp     type; };
-
-  template<typename _Tp, std::size_t _Size>
-    struct remove_extent<_Tp[_Size]>
-    { typedef _Tp     type; };
-
-  template<typename _Tp>
-    struct remove_extent<_Tp[]>
-    { typedef _Tp     type; };
-
-  /// remove_all_extents
-  template<typename _Tp>
-    struct remove_all_extents
-    { typedef _Tp     type; };
-
-  template<typename _Tp, std::size_t _Size>
-    struct remove_all_extents<_Tp[_Size]>
-    { typedef typename remove_all_extents<_Tp>::type     type; };
-
-  template<typename _Tp>
-    struct remove_all_extents<_Tp[]>
-    { typedef typename remove_all_extents<_Tp>::type     type; };
-
-  // pointer modifications [4.7.4].
-
-  template<typename _Tp, typename>
-    struct __remove_pointer_helper
-    { typedef _Tp     type; };
-
-  template<typename _Tp, typename _Up>
-    struct __remove_pointer_helper<_Tp, _Up*>
-    { typedef _Up     type; };
-
-  /// remove_pointer
-  template<typename _Tp>
-    struct remove_pointer
-    : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
-    { };
-
-  template<typename>
-    struct remove_reference;
-
-  /// add_pointer
-  template<typename _Tp>
-    struct add_pointer
-    { typedef typename remove_reference<_Tp>::type*     type; };
-
-#undef _DEFINE_SPEC_0_HELPER
-#undef _DEFINE_SPEC_1_HELPER
-#undef _DEFINE_SPEC_2_HELPER
-#undef _DEFINE_SPEC
-
-  // @} group metaprogramming
-_GLIBCXX_END_NAMESPACE_TR1
-}
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/unordered_map b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/unordered_map
deleted file mode 100644
index cef649042..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/unordered_map
+++ /dev/null
@@ -1,370 +0,0 @@
-// TR1 unordered_map -*- C++ -*-
-
-// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/unordered_map
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-  // XXX When we get typedef templates these class definitions
-  // will be unnecessary.
-  template<class _Key, class _Tp,
-	   class _Hash = hash<_Key>,
-	   class _Pred = std::equal_to<_Key>,
-	   class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
-	   bool __cache_hash_code = false>
-    class __unordered_map
-    : public _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
-			std::_Select1st<std::pair<const _Key, _Tp> >, _Pred, 
-			_Hash, __detail::_Mod_range_hashing,
-			__detail::_Default_ranged_hash,
-			__detail::_Prime_rehash_policy,
-			__cache_hash_code, false, true>
-    {
-      typedef _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
-			 std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
-			 _Hash, __detail::_Mod_range_hashing,
-			 __detail::_Default_ranged_hash,
-			 __detail::_Prime_rehash_policy,
-			 __cache_hash_code, false, true>
-        _Base;
-
-    public:
-      typedef typename _Base::size_type       size_type;
-      typedef typename _Base::hasher          hasher;
-      typedef typename _Base::key_equal       key_equal;
-      typedef typename _Base::allocator_type  allocator_type;
-
-      explicit
-      __unordered_map(size_type __n = 10,
-		      const hasher& __hf = hasher(),
-		      const key_equal& __eql = key_equal(),
-		      const allocator_type& __a = allocator_type())
-      : _Base(__n, __hf, __detail::_Mod_range_hashing(),
-	      __detail::_Default_ranged_hash(),
-	      __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
-      { }
-
-      template<typename _InputIterator>
-        __unordered_map(_InputIterator __f, _InputIterator __l, 
-			size_type __n = 10,
-			const hasher& __hf = hasher(), 
-			const key_equal& __eql = key_equal(), 
-			const allocator_type& __a = allocator_type())
-	: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
-		__detail::_Default_ranged_hash(),
-		__eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
-	{ }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      __unordered_map(__unordered_map&& __x)
-      : _Base(std::forward<_Base>(__x)) { }
-#endif
-    };
-  
-  template<class _Key, class _Tp,
-	   class _Hash = hash<_Key>,
-	   class _Pred = std::equal_to<_Key>,
-	   class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
-	   bool __cache_hash_code = false>
-    class __unordered_multimap
-    : public _Hashtable<_Key, std::pair<const _Key, _Tp>,
-			_Alloc,
-			std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
-			_Hash, __detail::_Mod_range_hashing,
-			__detail::_Default_ranged_hash,
-			__detail::_Prime_rehash_policy,
-			__cache_hash_code, false, false>
-    {
-      typedef _Hashtable<_Key, std::pair<const _Key, _Tp>,
-			 _Alloc,
-			 std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
-			 _Hash, __detail::_Mod_range_hashing,
-			 __detail::_Default_ranged_hash,
-			 __detail::_Prime_rehash_policy,
-			 __cache_hash_code, false, false>
-        _Base;
-
-    public:
-      typedef typename _Base::size_type       size_type;
-      typedef typename _Base::hasher          hasher;
-      typedef typename _Base::key_equal       key_equal;
-      typedef typename _Base::allocator_type  allocator_type;
-      
-      explicit
-      __unordered_multimap(size_type __n = 10,
-			   const hasher& __hf = hasher(),
-			   const key_equal& __eql = key_equal(),
-			   const allocator_type& __a = allocator_type())
-      : _Base(__n, __hf, __detail::_Mod_range_hashing(),
-	      __detail::_Default_ranged_hash(),
-	      __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
-      { }
-
-
-      template<typename _InputIterator>
-        __unordered_multimap(_InputIterator __f, _InputIterator __l, 
-			     typename _Base::size_type __n = 0,
-			     const hasher& __hf = hasher(), 
-			     const key_equal& __eql = key_equal(), 
-			     const allocator_type& __a = allocator_type())
-	: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
-		__detail::_Default_ranged_hash(),
-		__eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
-        { }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      __unordered_multimap(__unordered_multimap&& __x)
-      : _Base(std::forward<_Base>(__x)) { }
-#endif
-    };
-
-  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
-	   bool __cache_hash_code>
-    inline void
-    swap(__unordered_map<_Key, _Tp, _Hash, _Pred,
-	 _Alloc, __cache_hash_code>& __x,
-	 __unordered_map<_Key, _Tp, _Hash, _Pred,
-	 _Alloc, __cache_hash_code>& __y)
-    { __x.swap(__y); }
-
-  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
-	   bool __cache_hash_code>
-    inline void
-    swap(__unordered_multimap<_Key, _Tp, _Hash, _Pred,
-	 _Alloc, __cache_hash_code>& __x,
-	 __unordered_multimap<_Key, _Tp, _Hash, _Pred,
-	 _Alloc, __cache_hash_code>& __y)
-    { __x.swap(__y); }
-
-
-  /**
-   *  @brief A standard container composed of unique keys (containing
-   *  at most one of each key value) that associates values of another type
-   *  with the keys.
-   *
-   *  @ingroup unordered_associative_containers
-   *
-   *  Meets the requirements of a <a href="tables.html#65">container</a>, and
-   *  <a href="tables.html#xx">unordered associative container</a>
-   *
-   *  @param  Key  Type of key objects.
-   *  @param  Tp  Type of mapped objects.
-   *  @param  Hash  Hashing function object type, defaults to hash<Value>.
-   *  @param  Pred  Predicate function object type, defaults to equal_to<Value>.
-   *  @param  Alloc  Allocator type, defaults to allocator<Key>.
-   *
-   * The resulting value type of the container is std::pair<const Key, Tp>.
-   */
-  template<class _Key, class _Tp,
-	   class _Hash = hash<_Key>,
-	   class _Pred = std::equal_to<_Key>,
-	   class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
-    class unordered_map
-    : public __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
-    {
-      typedef __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>  _Base;
-
-    public:
-      typedef typename _Base::value_type      value_type;
-      typedef typename _Base::size_type       size_type;
-      typedef typename _Base::hasher          hasher;
-      typedef typename _Base::key_equal       key_equal;
-      typedef typename _Base::allocator_type  allocator_type;
-
-      explicit
-      unordered_map(size_type __n = 10,
-		    const hasher& __hf = hasher(),
-		    const key_equal& __eql = key_equal(),
-		    const allocator_type& __a = allocator_type())
-      : _Base(__n, __hf, __eql, __a)
-      { }
-
-      template<typename _InputIterator>
-        unordered_map(_InputIterator __f, _InputIterator __l, 
-		      size_type __n = 10,
-		      const hasher& __hf = hasher(), 
-		      const key_equal& __eql = key_equal(), 
-		      const allocator_type& __a = allocator_type())
-	: _Base(__f, __l, __n, __hf, __eql, __a)
-        { }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      unordered_map(unordered_map&& __x)
-      : _Base(std::forward<_Base>(__x)) { }
-
-      unordered_map(initializer_list<value_type> __l,
-		    size_type __n = 10,
-		    const hasher& __hf = hasher(),
-		    const key_equal& __eql = key_equal(),
-		    const allocator_type& __a = allocator_type())
-	: _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a)
-      { }
-
-      unordered_map&
-      operator=(unordered_map&& __x)
-      {
-	// NB: DR 675.
-	this->clear();
-	this->swap(__x); 
-	return *this;	
-      }
-
-      unordered_map&
-      operator=(initializer_list<value_type> __l)
-      {
-	this->clear();
-	this->insert(__l.begin(), __l.end());
-	return *this;
-      }
-#endif
-    };
-  
-  /**
-   *  @brief A standard container composed of equivalent keys
-   *  (possibly containing multiple of each key value) that associates
-   *  values of another type with the keys.
-   *
-   *  @ingroup unordered_associative_containers
-   *
-   *  Meets the requirements of a <a href="tables.html#65">container</a>, and
-   *  <a href="tables.html#xx">unordered associative container</a>
-   *
-   *  @param  Key  Type of key objects.
-   *  @param  Tp  Type of mapped objects.
-   *  @param  Hash  Hashing function object type, defaults to hash<Value>.
-   *  @param  Pred  Predicate function object type, defaults to equal_to<Value>.
-   *  @param  Alloc  Allocator type, defaults to allocator<Key>.
-   *
-   * The resulting value type of the container is std::pair<const Key, Tp>.
-   */
-  template<class _Key, class _Tp,
-	   class _Hash = hash<_Key>,
-	   class _Pred = std::equal_to<_Key>,
-	   class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
-    class unordered_multimap
-    : public __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
-    {
-      typedef __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>  _Base;
-
-    public:
-      typedef typename _Base::value_type      value_type;
-      typedef typename _Base::size_type       size_type;
-      typedef typename _Base::hasher          hasher;
-      typedef typename _Base::key_equal       key_equal;
-      typedef typename _Base::allocator_type  allocator_type;
-      
-      explicit
-      unordered_multimap(size_type __n = 10,
-			 const hasher& __hf = hasher(),
-			 const key_equal& __eql = key_equal(),
-			 const allocator_type& __a = allocator_type())
-      : _Base(__n, __hf, __eql, __a)
-      { }
-
-
-      template<typename _InputIterator>
-        unordered_multimap(_InputIterator __f, _InputIterator __l, 
-			   typename _Base::size_type __n = 0,
-			   const hasher& __hf = hasher(), 
-			   const key_equal& __eql = key_equal(), 
-			   const allocator_type& __a = allocator_type())
-	: _Base(__f, __l, __n, __hf, __eql, __a)
-        { }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      unordered_multimap(unordered_multimap&& __x)
-      : _Base(std::forward<_Base>(__x)) { }
-
-      unordered_multimap(initializer_list<value_type> __l,
-			 size_type __n = 10,
-			 const hasher& __hf = hasher(),
-			 const key_equal& __eql = key_equal(),
-			 const allocator_type& __a = allocator_type())
-	: _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a)
-      { }
-
-      unordered_multimap&
-      operator=(unordered_multimap&& __x)
-      {
-	// NB: DR 675.
-	this->clear();
-	this->swap(__x); 
-	return *this;	
-      }
-
-      unordered_multimap&
-      operator=(initializer_list<value_type> __l)
-      {
-	this->clear();
-	this->insert(__l.begin(), __l.end());
-	return *this;
-      }
-#endif
-    };
-
-  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-    inline void
-    swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
-	 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
-    { __x.swap(__y); }
-
-  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-    inline void
-    swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
-	 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
-    { __x.swap(__y); }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-    inline void
-    swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&& __x,
-	 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
-    { __x.swap(__y); }
-
-  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-    inline void
-    swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
-	 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&& __y)
-    { __x.swap(__y); }
-
-  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-    inline void
-    swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&& __x,
-	 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
-    { __x.swap(__y); }
-
-  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-    inline void
-    swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
-	 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&& __y)
-    { __x.swap(__y); }
-#endif
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/unordered_set b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/unordered_set
deleted file mode 100644
index fc2ce2b1e..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/unordered_set
+++ /dev/null
@@ -1,360 +0,0 @@
-// TR1 unordered_set -*- C++ -*-
-
-// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/unordered_set
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-namespace std
-{ 
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-  // XXX When we get typedef templates these class definitions
-  // will be unnecessary.
-  template<class _Value,
-	   class _Hash = hash<_Value>,
-	   class _Pred = std::equal_to<_Value>,
-	   class _Alloc = std::allocator<_Value>,
-	   bool __cache_hash_code = false>
-    class __unordered_set
-    : public _Hashtable<_Value, _Value, _Alloc,
-			std::_Identity<_Value>, _Pred,
-			_Hash, __detail::_Mod_range_hashing,
-			__detail::_Default_ranged_hash,
-			__detail::_Prime_rehash_policy,
-			__cache_hash_code, true, true>
-    {
-      typedef _Hashtable<_Value, _Value, _Alloc,
-			 std::_Identity<_Value>, _Pred,
-			 _Hash, __detail::_Mod_range_hashing,
-			 __detail::_Default_ranged_hash,
-			 __detail::_Prime_rehash_policy,
-			 __cache_hash_code, true, true>
-        _Base;
-
-    public:
-      typedef typename _Base::size_type       size_type;
-      typedef typename _Base::hasher          hasher;
-      typedef typename _Base::key_equal       key_equal;
-      typedef typename _Base::allocator_type  allocator_type;
-      
-      explicit
-      __unordered_set(size_type __n = 10,
-		      const hasher& __hf = hasher(),
-		      const key_equal& __eql = key_equal(),
-		      const allocator_type& __a = allocator_type())
-      : _Base(__n, __hf, __detail::_Mod_range_hashing(),
-	      __detail::_Default_ranged_hash(), __eql,
-	      std::_Identity<_Value>(), __a)
-      { }
-
-      template<typename _InputIterator>
-        __unordered_set(_InputIterator __f, _InputIterator __l, 
-			size_type __n = 10,
-			const hasher& __hf = hasher(), 
-			const key_equal& __eql = key_equal(), 
-			const allocator_type& __a = allocator_type())
-	: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
-		__detail::_Default_ranged_hash(), __eql,
-		std::_Identity<_Value>(), __a)
-        { }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      __unordered_set(__unordered_set&& __x)
-      : _Base(std::forward<_Base>(__x)) { }
-#endif
-    };
-
-  template<class _Value,
-	   class _Hash = hash<_Value>,
-	   class _Pred = std::equal_to<_Value>,
-	   class _Alloc = std::allocator<_Value>,
-	   bool __cache_hash_code = false>
-    class __unordered_multiset
-    : public _Hashtable<_Value, _Value, _Alloc,
-			std::_Identity<_Value>, _Pred,
-			_Hash, __detail::_Mod_range_hashing,
-			__detail::_Default_ranged_hash,
-			__detail::_Prime_rehash_policy,
-			__cache_hash_code, true, false>
-    {
-      typedef _Hashtable<_Value, _Value, _Alloc,
-			 std::_Identity<_Value>, _Pred,
-			 _Hash, __detail::_Mod_range_hashing,
-			 __detail::_Default_ranged_hash,
-			 __detail::_Prime_rehash_policy,
-			 __cache_hash_code, true, false>
-        _Base;
-
-    public:
-      typedef typename _Base::size_type       size_type;
-      typedef typename _Base::hasher          hasher;
-      typedef typename _Base::key_equal       key_equal;
-      typedef typename _Base::allocator_type  allocator_type;
-      
-      explicit
-      __unordered_multiset(size_type __n = 10,
-			   const hasher& __hf = hasher(),
-			   const key_equal& __eql = key_equal(),
-			   const allocator_type& __a = allocator_type())
-      : _Base(__n, __hf, __detail::_Mod_range_hashing(),
-	      __detail::_Default_ranged_hash(), __eql,
-	      std::_Identity<_Value>(), __a)
-      { }
-
-
-      template<typename _InputIterator>
-        __unordered_multiset(_InputIterator __f, _InputIterator __l, 
-			     typename _Base::size_type __n = 0,
-			     const hasher& __hf = hasher(), 
-			     const key_equal& __eql = key_equal(), 
-			     const allocator_type& __a = allocator_type())
-	: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
-		__detail::_Default_ranged_hash(), __eql,
-		std::_Identity<_Value>(), __a)
-        { }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      __unordered_multiset(__unordered_multiset&& __x)
-      : _Base(std::forward<_Base>(__x)) { }
-#endif
-    };
-
-  template<class _Value, class _Hash, class _Pred, class _Alloc,
-	   bool __cache_hash_code>
-    inline void
-    swap(__unordered_set<_Value, _Hash, _Pred, _Alloc, __cache_hash_code>& __x,
-	 __unordered_set<_Value, _Hash, _Pred, _Alloc, __cache_hash_code>& __y)
-    { __x.swap(__y); }
-
-  template<class _Value, class _Hash, class _Pred, class _Alloc,
-	   bool __cache_hash_code>
-    inline void
-    swap(__unordered_multiset<_Value, _Hash, _Pred,
-	 _Alloc, __cache_hash_code>& __x,
-	 __unordered_multiset<_Value, _Hash, _Pred,
-	 _Alloc, __cache_hash_code>& __y)
-    { __x.swap(__y); }
-
-
-  /**
-   *  @brief A standard container composed of unique keys (containing
-   *  at most one of each key value) in which the elements' keys are
-   *  the elements themselves.
-   *
-   *  @ingroup unordered_associative_containers
-   *
-   *  Meets the requirements of a <a href="tables.html#65">container</a>, and
-   *  <a href="tables.html#xx">unordered associative container</a>
-   *
-   *  @param  Value  Type of key objects.
-   *  @param  Hash  Hashing function object type, defaults to hash<Value>.
-   *  @param  Pred  Predicate function object type, defaults to equal_to<Value>.
-   *  @param  Alloc  Allocator type, defaults to allocator<Key>.
-   */
-  template<class _Value,
-	   class _Hash = hash<_Value>,
-	   class _Pred = std::equal_to<_Value>,
-	   class _Alloc = std::allocator<_Value> >
-    class unordered_set
-    : public __unordered_set<_Value, _Hash, _Pred, _Alloc>
-    {
-      typedef __unordered_set<_Value, _Hash, _Pred, _Alloc>  _Base;
-
-    public:
-      typedef typename _Base::value_type      value_type;
-      typedef typename _Base::size_type       size_type;
-      typedef typename _Base::hasher          hasher;
-      typedef typename _Base::key_equal       key_equal;
-      typedef typename _Base::allocator_type  allocator_type;
-      
-      explicit
-      unordered_set(size_type __n = 10,
-		    const hasher& __hf = hasher(),
-		    const key_equal& __eql = key_equal(),
-		    const allocator_type& __a = allocator_type())
-      : _Base(__n, __hf, __eql, __a)
-      { }
-
-      template<typename _InputIterator>
-        unordered_set(_InputIterator __f, _InputIterator __l, 
-		      size_type __n = 10,
-		      const hasher& __hf = hasher(), 
-		      const key_equal& __eql = key_equal(), 
-		      const allocator_type& __a = allocator_type())
-	: _Base(__f, __l, __n, __hf, __eql, __a)
-        { }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      unordered_set(unordered_set&& __x)
-      : _Base(std::forward<_Base>(__x)) { }
-
-      unordered_set(initializer_list<value_type> __l,
-		    size_type __n = 10,
-		    const hasher& __hf = hasher(),
-		    const key_equal& __eql = key_equal(),
-		    const allocator_type& __a = allocator_type())
-	: _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a)
-      { }
-
-      unordered_set&
-      operator=(unordered_set&& __x)
-      {
-	// NB: DR 675.
-	this->clear();
-	this->swap(__x); 
-	return *this;	
-      }
-
-      unordered_set&
-      operator=(initializer_list<value_type> __l)
-      {
-	this->clear();
-	this->insert(__l.begin(), __l.end());
-	return *this;
-      }
-#endif
-    };
-
-  /**
-   *  @brief A standard container composed of equivalent keys
-   *  (possibly containing multiple of each key value) in which the
-   *  elements' keys are the elements themselves.
-   *
-   *  @ingroup unordered_associative_containers
-   *
-   *  Meets the requirements of a <a href="tables.html#65">container</a>, and
-   *  <a href="tables.html#xx">unordered associative container</a>
-   *
-   *  @param  Value  Type of key objects.
-   *  @param  Hash  Hashing function object type, defaults to hash<Value>.
-   *  @param  Pred  Predicate function object type, defaults to equal_to<Value>.
-   *  @param  Alloc  Allocator type, defaults to allocator<Key>.
-   */
-  template<class _Value,
-	   class _Hash = hash<_Value>,
-	   class _Pred = std::equal_to<_Value>,
-	   class _Alloc = std::allocator<_Value> >
-    class unordered_multiset
-    : public __unordered_multiset<_Value, _Hash, _Pred, _Alloc>
-    {
-      typedef __unordered_multiset<_Value, _Hash, _Pred, _Alloc>  _Base;
-
-    public:
-      typedef typename _Base::value_type      value_type;
-      typedef typename _Base::size_type       size_type;
-      typedef typename _Base::hasher          hasher;
-      typedef typename _Base::key_equal       key_equal;
-      typedef typename _Base::allocator_type  allocator_type;
-      
-      explicit
-      unordered_multiset(size_type __n = 10,
-			 const hasher& __hf = hasher(),
-			 const key_equal& __eql = key_equal(),
-			 const allocator_type& __a = allocator_type())
-      : _Base(__n, __hf, __eql, __a)
-      { }
-
-
-      template<typename _InputIterator>
-        unordered_multiset(_InputIterator __f, _InputIterator __l, 
-			   typename _Base::size_type __n = 0,
-			   const hasher& __hf = hasher(), 
-			   const key_equal& __eql = key_equal(), 
-			   const allocator_type& __a = allocator_type())
-	: _Base(__f, __l, __n, __hf, __eql, __a)
-        { }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-      unordered_multiset(unordered_multiset&& __x)
-      : _Base(std::forward<_Base>(__x)) { }
-
-      unordered_multiset(initializer_list<value_type> __l,
-			 size_type __n = 10,
-			 const hasher& __hf = hasher(),
-			 const key_equal& __eql = key_equal(),
-			 const allocator_type& __a = allocator_type())
-	: _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a)
-      { }
-
-      unordered_multiset&
-      operator=(unordered_multiset&& __x)
-      {
-	// NB: DR 675.
-	this->clear();
-	this->swap(__x); 
-	return *this;	
-      }
-
-      unordered_multiset&
-      operator=(initializer_list<value_type> __l)
-      {
-	this->clear();
-	this->insert(__l.begin(), __l.end());
-	return *this;
-      }
-#endif
-    };
-
-  template<class _Value, class _Hash, class _Pred, class _Alloc>
-    inline void
-    swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
-	 unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
-    { __x.swap(__y); }
-
-  template<class _Value, class _Hash, class _Pred, class _Alloc>
-    inline void
-    swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
-	 unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
-    { __x.swap(__y); }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-  template<class _Value, class _Hash, class _Pred, class _Alloc>
-    inline void
-    swap(unordered_set<_Value, _Hash, _Pred, _Alloc>&& __x,
-	 unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
-    { __x.swap(__y); }
-
-  template<class _Value, class _Hash, class _Pred, class _Alloc>
-    inline void
-    swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
-	 unordered_set<_Value, _Hash, _Pred, _Alloc>&& __y)
-    { __x.swap(__y); }
-
-  template<class _Value, class _Hash, class _Pred, class _Alloc>
-    inline void
-    swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>&& __x,
-	 unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
-    { __x.swap(__y); }
-
-  template<class _Value, class _Hash, class _Pred, class _Alloc>
-    inline void
-    swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
-	 unordered_multiset<_Value, _Hash, _Pred, _Alloc>&& __y)
-    { __x.swap(__y); }
-#endif
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
diff --git a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/utility b/gcc-4.4.3/libstdc++-v3/include/tr1_impl/utility
deleted file mode 100644
index a31c4da87..000000000
--- a/gcc-4.4.3/libstdc++-v3/include/tr1_impl/utility
+++ /dev/null
@@ -1,120 +0,0 @@
-// TR1 utility -*- C++ -*-
-
-// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file tr1_impl/utility
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE_TR1
-
-  template<class _Tp>
-    class tuple_size;
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-  template<std::size_t _Int, class _Tp>
-#else
-  template<int _Int, class _Tp>
-#endif
-    class tuple_element;
-
-   // Various functions which give std::pair a tuple-like interface.
-  template<class _Tp1, class _Tp2>
-    struct tuple_size<std::pair<_Tp1, _Tp2> >
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-    { static const std::size_t value = 2; };
-#else
-    { static const int value = 2; };
-#endif
-
-  template<class _Tp1, class _Tp2>
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-    const std::size_t
-#else
-    const int
-#endif
-    tuple_size<std::pair<_Tp1, _Tp2> >::value;
-
-  template<class _Tp1, class _Tp2>
-    struct tuple_element<0, std::pair<_Tp1, _Tp2> >
-    { typedef _Tp1 type; };
- 
-  template<class _Tp1, class _Tp2>
-    struct tuple_element<1, std::pair<_Tp1, _Tp2> >
-    { typedef _Tp2 type; };
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-  template<std::size_t _Int>
-#else
-  template<int _Int>
-#endif
-    struct __pair_get;
-
-  template<>
-    struct __pair_get<0>
-    {
-      template<typename _Tp1, typename _Tp2>
-      static _Tp1& __get(std::pair<_Tp1, _Tp2>& __pair)
-      { return __pair.first; }
-
-      template<typename _Tp1, typename _Tp2>
-      static const _Tp1& __const_get(const std::pair<_Tp1, _Tp2>& __pair)
-      { return __pair.first; }
-    };
-
-  template<>
-    struct __pair_get<1>
-    {
-      template<typename _Tp1, typename _Tp2>
-      static _Tp2& __get(std::pair<_Tp1, _Tp2>& __pair)
-      { return __pair.second; }
-
-      template<typename _Tp1, typename _Tp2>
-      static const _Tp2& __const_get(const std::pair<_Tp1, _Tp2>& __pair)
-      { return __pair.second; }
-    };
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-  template<std::size_t _Int, class _Tp1, class _Tp2>
-#else
-  template<int _Int, class _Tp1, class _Tp2>
-#endif
-    inline typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
-    get(std::pair<_Tp1, _Tp2>& __in)
-    { return __pair_get<_Int>::__get(__in); }
-
-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
-  template<std::size_t _Int, class _Tp1, class _Tp2>
-#else
-  template<int _Int, class _Tp1, class _Tp2>
-#endif
-    inline const typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
-    get(const std::pair<_Tp1, _Tp2>& __in)
-    { return __pair_get<_Int>::__const_get(__in); }
-
-_GLIBCXX_END_NAMESPACE_TR1
-}
-