This commit was manufactured by cvs2svn to create tag

'Version_1_29_0'. [SVN r15904]
Fixes, notes.
2025-10-05 12:11:07 +02:00 · 2002-10-11 15:17:55 +00:00 · 2002-09-23 13:32:54 +00:00 · 2002-09-19 20:49:39 +00:00
162 changed files with 3688 additions and 20913 deletions
--- a/compatibility.htm
+++ b/compatibility.htm
@@ -1,88 +1,105 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
 		<title>Smart Pointer Changes</title>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <title>Smart Pointer Changes</title>
 </head>
-	<body bgcolor="#ffffff" text="#000000">
+
-		<h1><A href="../../index.htm"><img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="277" height="86"
+<body bgcolor="#FFFFFF" text="#000000">
-					border="0"></A>Smart Pointer Changes</h1>
+
-		<p>The February 2002 change to the Boost smart pointers introduced a number of 
+<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="middle" width="277" height="86">Smart
-			changes. Since the previous version of the smart pointers was in use for a long 
+Pointer Changes</h1>
-			time, it's useful to have a detailed list of what changed from a library user's 
+
-			point of view.</p>
+<p>The February 2002 change to the Boost smart pointers introduced a number
-		<p>Note that for compilers that don't support member templates well enough, a 
+of changes. Since the previous version of the smart pointers was in use for
-			separate implementation is used that lacks many of the new features and is more 
+a long time, it's useful to have a detailed list of what changed from a library
-			like the old version.</p>
+user's point of view.</p>
 <p>Note that for compilers that don't support member templates well enough,
 a separate implementation is used that lacks many of the new features and is
 more like the old version.</p>
 <h2>Features Requiring Code Changes to Take Advantage</h2>
 <ul>
-			<li>
+
-				The smart pointer class templates now each have their own header file. For 
+<li>The smart pointer class templates now each have their own header file.
-				compatibility, the <a href="../../boost/smart_ptr.hpp">&lt;boost/smart_ptr.hpp&gt;</a>
+For compatibility, the
-			header now includes the headers for the four classic smart pointer class 
+<a href="../../boost/smart_ptr.hpp">&lt;boost/smart_ptr.hpp&gt;</a>
-			templates.
+header now includes the headers for the four classic smart pointer class templates.</li>
-			<li>
+
-				The <b>weak_ptr</b>
+<li>The <b>weak_ptr</b> template was added.</li>
-			template was added.
+
-			<li>
+<li>The new <b>shared_ptr</b> and <b>shared_array</b> relax the requirement that the pointed-to object's
-				The new <b>shared_ptr</b> and <b>shared_array</b> relax the requirement that 
+destructor must be visible when instantiating the <b>shared_ptr</b> destructor.
-				the pointed-to object's destructor must be visible when instantiating the <b>shared_ptr</b>
+This makes it easier to have shared_ptr members in classes without explicit destructors.</li>
-			destructor. This makes it easier to have shared_ptr members in classes without 
+
-			explicit destructors.
+<li>A custom deallocator can be passed in when creating a <b>shared_ptr</b> or <b>shared_array</b>.</li>
-			<li>
+
-				A custom deallocator can be passed in when creating a <b>shared_ptr</b> or <b>shared_array</b>.
+<li><b>shared_static_cast</b> and <b>shared_dynamic_cast</b> function templates are
-			<li>
+provided which work for <b>shared_ptr</b> and <b>weak_ptr</b> as <b>static_cast</b> and
-				<b>shared_static_cast</b> and <b>shared_dynamic_cast</b> function templates are 
+<b>dynamic_cast</b> do for pointers.</li>
-				provided which work for <b>shared_ptr</b> and <b>weak_ptr</b> as <b>static_cast</b>
+
-				and <b>dynamic_cast</b>
+<li>The self-assignment misfeature has been removed from <b>shared_ptr::reset</b>,
 			do for pointers.
 			<li>
 				The self-assignment misfeature has been removed from <b>shared_ptr::reset</b>, 
 although it is still present in <b>scoped_ptr</b>, and in <b>std::auto_ptr</b>.
-				Calling <b>reset</b> with a pointer to the object that's already owned by the <b>shared_ptr</b>
+Calling <b>reset</b> with a pointer to the object that's already owned by the
-			results in undefined behavior (an assertion, or eventually a double-delete if 
+<b>shared_ptr</b> results in undefined behavior
-			assertions are off).
+(an assertion, or eventually a double-delete if assertions are off).</li>
-			<li>
+
-				The <b>BOOST_SMART_PTR_CONVERSION</b>
+<li>The <b>BOOST_SMART_PTR_CONVERSION</b> feature has been removed.</li>
-			feature has been removed.
+
-			<li>
+<li><b>shared_ptr&lt;void&gt;</b> is now allowed.</li>
-				<b>shared_ptr&lt;void&gt;</b> is now allowed.</li>
+
 </ul>
 <h2>Features That Improve Robustness</h2>
 <ul>
-			<li>
+
-				The manipulation of use counts is now <a name="threadsafe">thread safe</a> on 
+<li>The manipulation of use counts is now <a name="threadsafe">thread safe</a> on Windows, Linux, and platforms
-				Windows, Linux, and platforms that support pthreads. See the <a href="../../boost/detail/atomic_count.hpp">
+that support pthreads. See the
-					&lt;boost/detail/atomic_count.hpp&gt;</a>
+<a href="../../boost/detail/atomic_count.hpp">&lt;boost/detail/atomic_count.hpp&gt;</a>
-			file for details
+file for details</li>
-			<li>
+
-				The new shared_ptr will always delete the object using the pointer it was 
+<li>The new shared_ptr will always delete the object using the pointer it was originally constructed with.
-				originally constructed with. This prevents subtle problems that could happen if 
+This prevents subtle problems that could happen if the last <b>shared_ptr</b> was a pointer to a sub-object
-				the last <b>shared_ptr</b> was a pointer to a sub-object of a class that did 
+of a class that did not have a virtual destructor.</li>
-				not have a virtual destructor.</li>
+
 </ul>
 <h2>Implementation Details</h2>
 <ul>
-			<li>
+
-				Some bugs in the assignment operator implementations and in <b>reset</b>
+<li>Some bugs in the assignment operator implementations and in <b>reset</b>
-			have been fixed by using the "copy and swap" idiom.
+have been fixed by using the &quot;copy and swap&quot; idiom.</li>
-			<li>
+
-				Assertions have been added to check preconditions of various functions; 
+<li>Assertions have been added to check preconditions of various functions;
-				however, since these use the new <a href="../../boost/assert.hpp">&lt;boost/assert.hpp&gt;</a>
+however, since these use the new
-			header, the assertions are disabled by default.
+<a href="../../boost/assert.hpp">&lt;boost/assert.hpp&gt;</a>
-			<li>
+header, the assertions are disabled by default.</li>
-				The partial specialization of <b>std::less</b> has been replaced by <b>operator&lt;</b>
+
-			overloads which accomplish the same thing without relying on undefined 
+<li>The partial specialization of <b>std::less</b> has been replaced by <b>operator&lt;</b>
-			behavior.
+overloads which accomplish the same thing without relying on undefined behavior.</li>
-			<li>
+
-				The incorrect overload of <b>std::swap</b> has been replaced by <b>boost::swap</b>, 
+<li>The incorrect overload of <b>std::swap</b> has been replaced by <b>boost::swap</b>, which
-				which has many of the same advantages for generic programming but does not 
+has many of the same advantages for generic programming but does not violate the C++ standard.</li>
-				violate the C++ standard.</li>
+
 </ul>
 <hr>
 <p>Revised 1 February 2002</p>
-		<p><small>Copyright 2002 Darin Adler. Distributed under the Boost Software License, Version 
+
-				1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 
+<p>Copyright 2002 Darin Adler.
-				copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
+Permission to copy, use,
 modify, sell and distribute this document is granted provided this copyright
 notice appears in all copies. This document is provided &quot;as is&quot;
 without express or implied warranty, and with no claim as to its suitability for
 any purpose.</p>
 </body>
 </html>
--- a/enable_shared_from_this.html
+++ b/enable_shared_from_this.html
@@ -1,91 +0,0 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
 <html>
 	<head>
 		<title>Boost: enable_shared_from_this.hpp documentation</title>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
 	<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
 		<table border="0" width="100%">
 			<tr>
 				<td width="277"><A href="../../index.htm"> <img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86" border="0"></A>
 				</td>
 				<td align="center">
 					<h1>enable_shared_from_this.hpp</h1>
 				</td>
 			</tr>
 			<tr>
 				<td colspan="2" height="64">&nbsp;</td>
 			</tr>
 		</table>
 		<h3><a name="Purpose">Purpose</a></h3>
 		<p>
 			The header <STRONG>&lt;boost/enable_shared_from_this.hpp&gt;</STRONG> defines 
 			the class template <STRONG>enable_shared_from_this</STRONG>. It is used as a 
 			base class that allows a <A href="shared_ptr.htm">shared_ptr</A> to the current 
 			object to be obtained from within a member function.
 		</p>
 		<P><STRONG>enable_shared_from_this&lt;T&gt;</STRONG> defines two member functions 
 			called <STRONG>shared_from_this</STRONG> that return a <STRONG>shared_ptr&lt;T&gt;</STRONG>
 			and <STRONG>shared_ptr&lt;T const&gt;</STRONG>, depending on constness, to <STRONG>this</STRONG>.</P>
 		<h3><a name="Example">Example</a></h3>
 		<pre>
 class Y: public enable_shared_from_this&lt;Y&gt;
 {
 public:
    shared_ptr&lt;Y&gt; f()
    {
        return shared_from_this();
    }
 }
 int main()
 {
    shared_ptr&lt;Y&gt; p(new Y);
    shared_ptr&lt;Y&gt; q = p-&gt;f();
    assert(p == q);
    assert(!(p &lt; q || q &lt; p)); // p and q must share ownership
 }
 </pre>
 		<h3><a name="Synopsis">Synopsis</a></h3>
 		<pre>
 namespace boost
 {
 template&lt;class T&gt; class enable_shared_from_this
 {
 public:
    shared_ptr&lt;T&gt; shared_from_this();
    shared_ptr&lt;T const&gt; shared_from_this() const;
 }
 }
 </pre>
 		<h4>template&lt;class T&gt; shared_ptr&lt;T&gt; 
 			enable_shared_from_this&lt;T&gt;::shared_from_this();</h4>
 		<h4>template&lt;class T&gt; shared_ptr&lt;T const&gt; 
 			enable_shared_from_this&lt;T&gt;::shared_from_this() const;</h4>
 		<blockquote>
 			<p>
 				<b>Requires:</b> <STRONG>enable_shared_from_this&lt;T&gt;</STRONG> must be an 
 				accessible base class of <b>T</b>. <STRONG>*this</STRONG> must be a subobject 
 				of an instance <STRONG>t</STRONG> of type <STRONG>T</STRONG> . There must exist 
 				at least one <STRONG>shared_ptr</STRONG> instance <STRONG>p</STRONG> that <EM>owns</EM>
 				<STRONG>t</STRONG>.
 			</p>
 			<p>
 				<b>Returns:</b> A <b>shared_ptr&lt;T&gt;</b> instance <b>r</b> that shares 
 				ownership with <b>p</b>.
 			</p>
 			<p>
 				<b>Postconditions:</b> <tt>r.get() == this</tt>.
 			</p>
 		</blockquote>
 		<p>
 			<br>
 			<small>Copyright <20> 2002, 2003 by Peter Dimov. Distributed under the Boost Software License, Version 
 				1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 
 				copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
 	</body>
 </html>
--- a/example/scoped_ptr_example_test.cpp
+++ b/example/scoped_ptr_example_test.cpp
@@ -1,17 +0,0 @@
 // Boost scoped_ptr_example_test main program  -------------------------------//
 //  Copyright Beman Dawes 2001.  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)
 //  See http://www.boost.org/libs/smart_ptr for documentation.
 #include "scoped_ptr_example.hpp"
 int main()
 {
  example my_example;
  my_example.do_something();
  return 0;
 }
--- a/include/boost/detail/atomic_count.hpp
+++ b/include/boost/detail/atomic_count.hpp
@@ -1,9 +1,7 @@
 #ifndef BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
 #define BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
-// MS compatible compilers support #pragma once
+#if _MSC_VER >= 1020
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 #pragma once
 #endif
@@ -12,10 +10,114 @@
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //
-//  Distributed under the Boost Software License, Version 1.0.
+//  Permission to copy, use, modify, sell and distribute this software
-//  See accompanying file LICENSE_1_0.txt or copy at
+//  is granted provided this copyright notice appears in all copies.
-//  http://www.boost.org/LICENSE_1_0.txt
+//  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 //  typedef <implementation-defined> boost::detail::atomic_count;
 //
 //  atomic_count a(n);
 //
 //    (n is convertible to long)
 //
 //    Effects: Constructs an atomic_count with an initial value of n
 //
 //  a;
 //
 //    Returns: (long) the current value of a
 //
 //  ++a;
 //
 //    Effects: Atomically increments the value of a
 //    Returns: nothing
 //
 //  --a;
 //
 //    Effects: Atomically decrements the value of a
 //    Returns: (long) zero if the new value of a is zero,
 //      unspecified non-zero value otherwise (usually the new value)
 //
 //    Important note: when --a returns zero, it must act as a
 //      read memory barrier (RMB); i.e. the calling thread must
 //      have a synchronized view of the memory
 //
 //    On Intel IA-32 (x86) memory is always synchronized, so this
 //      is not a problem.
 //
 //    On many architectures the atomic instructions already act as
 //      a memory barrier.
 //
 //    This property is necessary for proper reference counting, since
 //      a thread can update the contents of a shared object, then
 //      release its reference, and another thread may immediately
 //      release the last reference causing object destruction.
 //
 //    The destructor needs to have a synchronized view of the
 //      object to perform proper cleanup.
 //
 //    Original example by Alexander Terekhov:
 //
 //    Given:
 //
 //    - a mutable shared object OBJ;
 //    - two threads THREAD1 and THREAD2 each holding 
 //      a private smart_ptr object pointing to that OBJ.
 //
 //    t1: THREAD1 updates OBJ (thread-safe via some synchronization)
 //      and a few cycles later (after "unlock") destroys smart_ptr;
 //
 //    t2: THREAD2 destroys smart_ptr WITHOUT doing any synchronization 
 //      with respect to shared mutable object OBJ; OBJ destructors
 //      are called driven by smart_ptr interface...
 //
-#include <boost/smart_ptr/detail/atomic_count.hpp>
+//  Note: atomic_count_linux.hpp has been disabled by default; see the
 //        comments inside for more info.
 #include <boost/config.hpp>
 #ifndef BOOST_HAS_THREADS
 namespace boost
 {
 namespace detail
 {
 typedef long atomic_count;
 }
 }
 #elif defined(BOOST_USE_ASM_ATOMIC_H)
 #  include <boost/detail/atomic_count_linux.hpp>
 #elif defined(BOOST_AC_USE_PTHREADS)
 #  include <boost/detail/atomic_count_pthreads.hpp>
 #elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
 #  include <boost/detail/atomic_count_win32.hpp>
 #elif defined(__GLIBCPP__)
 #  include <boost/detail/atomic_count_gcc.hpp>
 #elif defined(BOOST_HAS_PTHREADS)
 #  define BOOST_AC_USE_PTHREADS
 #  include <boost/detail/atomic_count_pthreads.hpp>
 #else
 // #warning Unrecognized platform, detail::atomic_count will not be thread safe
 namespace boost
 {
 namespace detail
 {
 typedef long atomic_count;
 }
 }
 #endif
 #endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
--- a/include/boost/detail/atomic_count_gcc.hpp
+++ b/include/boost/detail/atomic_count_gcc.hpp
@@ -0,0 +1,61 @@
 #ifndef BOOST_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED
 #define BOOST_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED
 //
 //  boost/detail/atomic_count_gcc.hpp
 //
 //  atomic_count for GNU libstdc++ v3
 //
 //  http://gcc.gnu.org/onlinedocs/porting/Thread-safety.html
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //  Copyright (c) 2002 Lars Gullik Bj<42>nnes <larsbj@lyx.org>
 //
 //  Permission to copy, use, modify, sell and distribute this software
 //  is granted provided this copyright notice appears in all copies.
 //  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 #include <bits/atomicity.h>
 namespace boost
 {
 namespace detail
 {
 class atomic_count
 {
 public:
    explicit atomic_count(long v) : value_(v) {}
    void operator++()
    {
        __atomic_add(&value_, 1);
    }
    long operator--()
    {
        return !__exchange_and_add(&value_, -1);
    }
    operator long() const
    {
        return __exchange_and_add(&value_, 0);
    }
 private:
    atomic_count(atomic_count const &);
    atomic_count & operator=(atomic_count const &);
    _Atomic_word value_;
 };
 } // namespace detail
 } // namespace boost
 #endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED
--- a/include/boost/detail/atomic_count_linux.hpp
+++ b/include/boost/detail/atomic_count_linux.hpp
@@ -0,0 +1,70 @@
 #ifndef BOOST_DETAIL_ATOMIC_COUNT_LINUX_HPP_INCLUDED
 #define BOOST_DETAIL_ATOMIC_COUNT_LINUX_HPP_INCLUDED
 //
 //  boost/detail/atomic_count_linux.hpp
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //
 //  Permission to copy, use, modify, sell and distribute this software
 //  is granted provided this copyright notice appears in all copies.
 //  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 //
 //  This implementation uses <asm/atomic.h>. This is a kernel header;
 //  using kernel headers in a user program may cause a number of problems,
 //  and not all flavors of Linux provide the atomic instructions.
 //
 //  This file is only provided because the performance of this implementation
 //  is significantly higher than the pthreads version. Use at your own risk
 //  (by defining BOOST_USE_ASM_ATOMIC_H.)
 //
 #include <asm/atomic.h>
 namespace boost
 {
 namespace detail
 {
 class atomic_count
 {
 public:
    explicit atomic_count(long v)
    {
        atomic_t init = ATOMIC_INIT(v);
        value_ = init;
    }
    void operator++()
    {
        atomic_inc(&value_);
    }
    long operator--()
    {
        return !atomic_dec_and_test(&value_);
    }
    operator long() const
    {
        return atomic_read(&value_);
    }
 private:
    atomic_count(atomic_count const &);
    atomic_count & operator=(atomic_count const &);
    atomic_t value_;
 };
 } // namespace detail
 } // namespace boost
 #endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_LINUX_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/atomic_count_pthreads.hpp
+++ b/include/boost/smart_ptr/detail/atomic_count_pthreads.hpp
@@ -1,14 +1,15 @@
-#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
+#ifndef BOOST_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
+#define BOOST_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
 //
 //  boost/detail/atomic_count_pthreads.hpp
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //
-// Distributed under the Boost Software License, Version 1.0. (See
+//  Permission to copy, use, modify, sell and distribute this software
-// accompanying file LICENSE_1_0.txt or copy at
+//  is granted provided this copyright notice appears in all copies.
-// http://www.boost.org/LICENSE_1_0.txt)
+//  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 #include <pthread.h>
@@ -62,10 +63,10 @@ public:
        pthread_mutex_destroy(&mutex_);
    }
-    long operator++()
+    void operator++()
    {
        scoped_lock lock(mutex_);
-        return ++value_;
+        ++value_;
    }
    long operator--()
@@ -93,4 +94,4 @@ private:
 } // namespace boost
-#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
+#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
--- a/include/boost/detail/atomic_count_win32.hpp
+++ b/include/boost/detail/atomic_count_win32.hpp
@@ -0,0 +1,62 @@
 #ifndef BOOST_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
 #define BOOST_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
 #if _MSC_VER >= 1020
 #pragma once
 #endif
 //
 //  boost/detail/atomic_count_win32.hpp
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //
 //  Permission to copy, use, modify, sell and distribute this software
 //  is granted provided this copyright notice appears in all copies.
 //  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 #include <boost/detail/winapi.hpp>
 namespace boost
 {
 namespace detail
 {
 class atomic_count
 {
 public:
    explicit atomic_count(long v): value_(v)
    {
    }
    long operator++()
    {
        return winapi::InterlockedIncrement(&value_);
    }
    long operator--()
    {
        return winapi::InterlockedDecrement(&value_);
    }
    operator long() const
    {
        return value_;
    }
 private:
    atomic_count(atomic_count const &);
    atomic_count & operator=(atomic_count const &);
    volatile long value_;
 };
 } // namespace detail
 } // namespace boost
 #endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
--- a/include/boost/detail/lightweight_mutex.hpp
+++ b/include/boost/detail/lightweight_mutex.hpp
@@ -1,22 +1,88 @@
 #ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
 #define BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
-// MS compatible compilers support #pragma once
+#if _MSC_VER >= 1020
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 #pragma once
 #endif
 //
 //  boost/detail/lightweight_mutex.hpp - lightweight mutex
 //
-//  Copyright (c) 2002, 2003 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
-//  Distributed under the Boost Software License, Version 1.0.
+//  Permission to copy, use, modify, sell and distribute this software
-//  See accompanying file LICENSE_1_0.txt or copy at
+//  is granted provided this copyright notice appears in all copies.
-//  http://www.boost.org/LICENSE_1_0.txt
+//  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 //  typedef <unspecified> boost::detail::lightweight_mutex;
 //
 //  boost::detail::lightweight_mutex meets a subset of the Mutex concept
 //  requirements: http://www.boost.org/libs/thread/doc/mutex_concept.html#Mutex
 //
 //  * Used by the smart pointer library
 //  * Performance oriented
 //  * Header-only implementation
 //  * Small memory footprint
 //  * Not a general purpose mutex, use boost::mutex, CRITICAL_SECTION or
 //    pthread_mutex instead.
 //  * Never spin in a tight lock/do-something/unlock loop, since
 //    lightweight_mutex does not guarantee fairness.
 //  * Never keep a lightweight_mutex locked for long periods.
 //
 //  The current implementation can use a pthread_mutex, a CRITICAL_SECTION,
 //  or a platform-specific spinlock.
 //
 //  You can force a particular implementation by defining BOOST_LWM_USE_PTHREADS,
 //  BOOST_LWM_USE_CRITICAL_SECTION, or BOOST_LWM_USE_SPINLOCK.
 //
 //  If neither macro has been defined, the default is to use a spinlock on Win32,
 //  and a pthread_mutex otherwise.
 //
 //  Note that a spinlock is not a general synchronization primitive. In particular,
 //  it is not guaranteed to be a memory barrier, and it is possible to "livelock"
 //  if a lower-priority thread has acquired the spinlock but a higher-priority
 //  thread is spinning trying to acquire the same lock.
 //
 //  For these reasons, spinlocks have been disabled by default except on Windows,
 //  where a spinlock can be several orders of magnitude faster than a CRITICAL_SECTION.
-#include <boost/smart_ptr/detail/lightweight_mutex.hpp>
+
 //  Note: lwm_linux.hpp has been disabled by default; see the comments
 //        inside for more info.
 #include <boost/config.hpp>
 //  Note to implementors: if you write a platform-specific spinlock
 //  for a platform that supports pthreads, be sure to test its performance
 //  against the pthreads-based version using shared_ptr_timing_test.cpp and
 //  shared_ptr_mt_test.cpp. Custom versions are usually not worth the trouble
 //  _unless_ the performance gains are substantial.
 //
 //  Be sure to compare against a "real" pthreads library;
 //  shared_ptr_timing_test.cpp will compile succesfully with a stub do-nothing
 //  pthreads library, since it doesn't create any threads.
 #ifndef BOOST_HAS_THREADS
 #  include <boost/detail/lwm_nop.hpp>
 #elif defined(BOOST_LWM_USE_SPINLOCK) && defined(BOOST_USE_ASM_ATOMIC_H)
 #  include <boost/detail/lwm_linux.hpp>
 #elif defined(BOOST_LWM_USE_CRITICAL_SECTION)
 #  include <boost/detail/lwm_win32_cs.hpp>
 #elif defined(BOOST_LWM_USE_PTHREADS)
 #  include <boost/detail/lwm_pthreads.hpp>
 #elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
 #  include <boost/detail/lwm_win32.hpp>
 #elif defined(BOOST_LWM_USE_SPINLOCK) && defined(__sgi)
 #  include <boost/detail/lwm_irix.hpp>
 #elif defined(BOOST_LWM_USE_SPINLOCK) && defined(__GLIBCPP__)
 #  include <boost/detail/lwm_gcc.hpp>
 #elif defined(BOOST_HAS_PTHREADS)
 #  define BOOST_LWM_USE_PTHREADS
 #  include <boost/detail/lwm_pthreads.hpp>
 #else
 #  include <boost/detail/lwm_nop.hpp>
 #endif
 #endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
--- a/include/boost/detail/lwm_gcc.hpp
+++ b/include/boost/detail/lwm_gcc.hpp
@@ -0,0 +1,78 @@
 #ifndef BOOST_DETAIL_LWM_GCC_HPP_INCLUDED
 #define BOOST_DETAIL_LWM_GCC_HPP_INCLUDED
 //
 //  boost/detail/lwm_gcc.hpp
 //
 //  lightweight_mutex for GNU libstdc++ v3
 //
 //  http://gcc.gnu.org/onlinedocs/porting/Thread-safety.html
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //  Copyright (c) 2002 Lars Gullik Bj<42>nnes <larsbj@lyx.org>
 //
 //  Permission to copy, use, modify, sell and distribute this software
 //  is granted provided this copyright notice appears in all copies.
 //  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 #include <bits/atomicity.h>
 #include <sched.h>
 namespace boost
 {
 namespace detail
 {
 class lightweight_mutex
 {
 private:
    _Atomic_word a_;
    lightweight_mutex(lightweight_mutex const &);
    lightweight_mutex & operator=(lightweight_mutex const &);
 public:
    lightweight_mutex(): a_(1)
    {
    }
    class scoped_lock;
    friend class scoped_lock;
    class scoped_lock
    {
    private:
        lightweight_mutex & m_;
        scoped_lock(scoped_lock const &);
        scoped_lock & operator=(scoped_lock const &);
    public:
        explicit scoped_lock(lightweight_mutex & m): m_(m)
        {
            while( !__exchange_and_add(&m_.a_, -1) )
            {
                __atomic_add(&m_.a_, 1);
                sched_yield();
            }
        }
        ~scoped_lock()
        {
            __atomic_add(&m_.a_, 1);
        }
    };
 };
 } // namespace detail
 } // namespace boost
 #endif // #ifndef BOOST_DETAIL_LWM_GCC_HPP_INCLUDED
--- a/include/boost/detail/lwm_irix.hpp
+++ b/include/boost/detail/lwm_irix.hpp
@@ -0,0 +1,78 @@
 #ifndef BOOST_DETAIL_LWM_IRIX_HPP_INCLUDED
 #define BOOST_DETAIL_LWM_IRIX_HPP_INCLUDED
 #if _MSC_VER >= 1020
 #pragma once
 #endif
 //
 //  boost/detail/lwm_irix.hpp
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //  Copyright (c) 2002 Dan Gohman
 //
 //  Permission to copy, use, modify, sell and distribute this software
 //  is granted provided this copyright notice appears in all copies.
 //  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 #include <sgidefs.h>
 #include <mutex.h>
 #include <sched.h>
 namespace boost
 {
 namespace detail
 {
 class lightweight_mutex
 {
 private:
    __uint32_t l_;
    lightweight_mutex(lightweight_mutex const &);
    lightweight_mutex & operator=(lightweight_mutex const &);
 public:
    lightweight_mutex(): l_(0)
    {
    }
    class scoped_lock;
    friend class scoped_lock;
    class scoped_lock
    {
    private:
        lightweight_mutex & m_;
        scoped_lock(scoped_lock const &);
        scoped_lock & operator=(scoped_lock const &);
    public:
        explicit scoped_lock(lightweight_mutex & m): m_(m)
        {
            while( test_and_set32(&m_.l_, 1) )
            {
                sched_yield();
            }
        }
        ~scoped_lock()
        {
            m_.l_ = 0;
        }
    };
 };
 } // namespace detail
 } // namespace boost
 #endif // #ifndef BOOST_DETAIL_LWM_IRIX_HPP_INCLUDED
--- a/include/boost/detail/lwm_linux.hpp
+++ b/include/boost/detail/lwm_linux.hpp
@@ -0,0 +1,89 @@
 #ifndef BOOST_DETAIL_LWM_LINUX_HPP_INCLUDED
 #define BOOST_DETAIL_LWM_LINUX_HPP_INCLUDED
 #if _MSC_VER >= 1020
 #pragma once
 #endif
 //
 //  boost/detail/lwm_linux.hpp
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
 //  Permission to copy, use, modify, sell and distribute this software
 //  is granted provided this copyright notice appears in all copies.
 //  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 //
 //  This implementation uses <asm/atomic.h>. This is a kernel header;
 //  using kernel headers in a user program may cause a number of problems,
 //  and not all flavors of Linux provide the atomic instructions.
 //
 //  This file is only provided because the performance of this implementation
 //  is about 3.5 times higher than the pthreads version. Use at your own risk
 //  (by defining BOOST_USE_ASM_ATOMIC_H.)
 //
 #include <asm/atomic.h>
 #include <sched.h>
 namespace boost
 {
 namespace detail
 {
 class lightweight_mutex
 {
 private:
    atomic_t a_;
    lightweight_mutex(lightweight_mutex const &);
    lightweight_mutex & operator=(lightweight_mutex const &);
 public:
    lightweight_mutex()
    {
        atomic_t a = ATOMIC_INIT(1);
        a_ = a;
    }
    class scoped_lock;
    friend class scoped_lock;
    class scoped_lock
    {
    private:
        lightweight_mutex & m_;
        scoped_lock(scoped_lock const &);
        scoped_lock & operator=(scoped_lock const &);
    public:
        explicit scoped_lock(lightweight_mutex & m): m_(m)
        {
            while( !atomic_dec_and_test(&m_.a_) )
            {
                atomic_inc(&m_.a_);
                sched_yield();
            }
        }
        ~scoped_lock()
        {
            atomic_inc(&m_.a_);
        }
    };
 };
 } // namespace detail
 } // namespace boost
 #endif // #ifndef BOOST_DETAIL_LWM_LINUX_HPP_INCLUDED
--- a/include/boost/detail/lwm_nop.hpp
+++ b/include/boost/detail/lwm_nop.hpp
@@ -0,0 +1,36 @@
 #ifndef BOOST_DETAIL_LWM_NOP_HPP_INCLUDED
 #define BOOST_DETAIL_LWM_NOP_HPP_INCLUDED
 #if _MSC_VER >= 1020
 #pragma once
 #endif
 //
 //  boost/detail/lwm_nop.hpp
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
 //  Permission to copy, use, modify, sell and distribute this software
 //  is granted provided this copyright notice appears in all copies.
 //  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 namespace boost
 {
 namespace detail
 {
 class lightweight_mutex
 {
 public:
    typedef lightweight_mutex scoped_lock;
 };
 } // namespace detail
 } // namespace boost
 #endif // #ifndef BOOST_DETAIL_LWM_NOP_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/lwm_pthreads.hpp
+++ b/include/boost/smart_ptr/detail/lwm_pthreads.hpp
@@ -1,9 +1,7 @@
-#ifndef BOOST_SMART_PTR_DETAIL_LWM_PTHREADS_HPP_INCLUDED
+#ifndef BOOST_DETAIL_LWM_PTHREADS_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_LWM_PTHREADS_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_PTHREADS_HPP_INCLUDED
-// MS compatible compilers support #pragma once
+#if _MSC_VER >= 1020
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 #pragma once
 #endif
@@ -12,9 +10,10 @@
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
-// Distributed under the Boost Software License, Version 1.0. (See
+//  Permission to copy, use, modify, sell and distribute this software
-// accompanying file LICENSE_1_0.txt or copy at
+//  is granted provided this copyright notice appears in all copies.
-// http://www.boost.org/LICENSE_1_0.txt)
+//  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 #include <pthread.h>
@@ -83,4 +82,4 @@ public:
 } // namespace boost
-#endif // #ifndef BOOST_SMART_PTR_DETAIL_LWM_PTHREADS_HPP_INCLUDED
+#endif // #ifndef BOOST_DETAIL_LWM_PTHREADS_HPP_INCLUDED
--- a/include/boost/detail/lwm_win32.hpp
+++ b/include/boost/detail/lwm_win32.hpp
@@ -0,0 +1,94 @@
 #ifndef BOOST_DETAIL_LWM_WIN32_HPP_INCLUDED
 #define BOOST_DETAIL_LWM_WIN32_HPP_INCLUDED
 #if _MSC_VER >= 1020
 #pragma once
 #endif
 //
 //  boost/detail/lwm_win32.hpp
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
 //  Permission to copy, use, modify, sell and distribute this software
 //  is granted provided this copyright notice appears in all copies.
 //  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 #include <boost/detail/winapi.hpp>
 #ifdef __BORLANDC__
 # pragma warn -8027     // Functions containing while are not expanded inline
 #endif
 namespace boost
 {
 namespace detail
 {
 class lightweight_mutex
 {
 private:
    long l_;
    lightweight_mutex(lightweight_mutex const &);
    lightweight_mutex & operator=(lightweight_mutex const &);
 public:
    lightweight_mutex(): l_(0)
    {
    }
    class scoped_lock;
    friend class scoped_lock;
    class scoped_lock
    {
    private:
        lightweight_mutex & m_;
        scoped_lock(scoped_lock const &);
        scoped_lock & operator=(scoped_lock const &);
    public:
        explicit scoped_lock(lightweight_mutex & m): m_(m)
        {
            while( winapi::InterlockedExchange(&m_.l_, 1) )
            {
                // Note: changed to Sleep(1) from Sleep(0).
                // According to MSDN, Sleep(0) will never yield
                // to a lower-priority thread, whereas Sleep(1)
                // will. Performance seems not to be affected.
                winapi::Sleep(1);
            }
        }
        ~scoped_lock()
        {
            winapi::InterlockedExchange(&m_.l_, 0);
            // Note: adding a yield here will make
            // the spinlock more fair and will increase the overall
            // performance of some applications substantially in
            // high contention situations, but will penalize the
            // low contention / single thread case up to 5x
        }
    };
 };
 } // namespace detail
 } // namespace boost
 #ifdef __BORLANDC__
 # pragma warn .8027     // Functions containing while are not expanded inline
 #endif
 #endif // #ifndef BOOST_DETAIL_LWM_WIN32_HPP_INCLUDED
--- a/include/boost/detail/lwm_win32_cs.hpp
+++ b/include/boost/detail/lwm_win32_cs.hpp
@@ -0,0 +1,78 @@
 #ifndef BOOST_DETAIL_LWM_WIN32_CS_HPP_INCLUDED
 #define BOOST_DETAIL_LWM_WIN32_CS_HPP_INCLUDED
 #if _MSC_VER >= 1020
 #pragma once
 #endif
 //
 //  boost/detail/lwm_win32_cs.hpp
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
 //  Permission to copy, use, modify, sell and distribute this software
 //  is granted provided this copyright notice appears in all copies.
 //  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 #include <boost/detail/winapi.hpp>
 namespace boost
 {
 namespace detail
 {
 class lightweight_mutex
 {
 private:
    winapi::critical_section cs_;
    lightweight_mutex(lightweight_mutex const &);
    lightweight_mutex & operator=(lightweight_mutex const &);
 public:
    lightweight_mutex()
    {
        winapi::InitializeCriticalSection(&cs_);
    }
    ~lightweight_mutex()
    {
        winapi::DeleteCriticalSection(&cs_);
    }
    class scoped_lock;
    friend class scoped_lock;
    class scoped_lock
    {
    private:
        lightweight_mutex & m_;
        scoped_lock(scoped_lock const &);
        scoped_lock & operator=(scoped_lock const &);
    public:
        explicit scoped_lock(lightweight_mutex & m): m_(m)
        {
            winapi::EnterCriticalSection(&m_.cs_);
        }
        ~scoped_lock()
        {
            winapi::LeaveCriticalSection(&m_.cs_);
        }
    };
 };
 } // namespace detail
 } // namespace boost
 #endif // #ifndef BOOST_DETAIL_LWM_WIN32_CS_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/shared_array_nmt.hpp
+++ b/include/boost/smart_ptr/detail/shared_array_nmt.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_SMART_PTR_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED
+#ifndef BOOST_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED
+#define BOOST_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED
 //
 //  detail/shared_array_nmt.hpp - shared_array.hpp without member templates
@@ -7,9 +7,10 @@
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
 //  Copyright (c) 2001, 2002 Peter Dimov
 //
-//  Distributed under the Boost Software License, Version 1.0. (See
+//  Permission to copy, use, modify, sell and distribute this software
-//  accompanying file LICENSE_1_0.txt or copy at
+//  is granted provided this copyright notice appears in all copies.
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 //  See http://www.boost.org/libs/smart_ptr/shared_array.htm for documentation.
 //
@@ -17,7 +18,7 @@
 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/throw_exception.hpp>
-#include <boost/smart_ptr/detail/atomic_count.hpp>
+#include <boost/detail/atomic_count.hpp>
 #include <cstddef>          // for std::ptrdiff_t
 #include <algorithm>        // for std::swap
@@ -148,4 +149,4 @@ template<class T> void swap(shared_array<T> & a, shared_array<T> & b)
 } // namespace boost
-#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED
+#endif  // #ifndef BOOST_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED
--- a/include/boost/detail/shared_count.hpp
+++ b/include/boost/detail/shared_count.hpp
@@ -0,0 +1,445 @@
 #ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED
 #define BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED
 #if _MSC_VER >= 1020
 #pragma once
 #endif
 //
 //  detail/shared_count.hpp
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //
 //  Permission to copy, use, modify, sell and distribute this software
 //  is granted provided this copyright notice appears in all copies.
 //  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 #include <boost/config.hpp>
 #ifndef BOOST_NO_AUTO_PTR
 # include <memory>
 #endif
 #include <boost/checked_delete.hpp>
 #include <boost/throw_exception.hpp>
 #include <boost/detail/lightweight_mutex.hpp>
 #include <functional>       // for std::less
 #include <exception>        // for std::exception
 #include <new>              // for std::bad_alloc
 #ifdef __BORLANDC__
 # pragma warn -8026     // Functions with excep. spec. are not expanded inline
 # pragma warn -8027     // Functions containing try are not expanded inline
 #endif
 namespace boost
 {
 // The standard library that comes with Borland C++ 5.5.1
 // defines std::exception and its members as having C calling
 // convention (-pc). When the definition of use_count_is_zero
 // is compiled with -ps, the compiler issues an error.
 // Hence, the temporary #pragma option -pc below. The version
 // check is deliberately conservative.
 #if defined(__BORLANDC__) && __BORLANDC__ == 0x551
 # pragma option push -pc
 #endif
 class use_count_is_zero: public std::exception
 {
 public:
    virtual char const * what() const throw()
    {
        return "boost::use_count_is_zero";
    }
 };
 #if defined(__BORLANDC__) && __BORLANDC__ == 0x551
 # pragma option pop
 #endif
 class counted_base
 {
 private:
    typedef detail::lightweight_mutex mutex_type;
 public:
    counted_base():
        use_count_(0), weak_count_(0)
    {
    }
    // pre: initial_use_count <= initial_weak_count
    explicit counted_base(long initial_use_count, long initial_weak_count):
        use_count_(initial_use_count), weak_count_(initial_weak_count)
    {
    }
    virtual ~counted_base() // nothrow
    {
    }
    // dispose() is called when use_count_ drops to zero, to release
    // the resources managed by *this.
    //
    // counted_base doesn't manage any resources except itself, and
    // the default implementation is a no-op.
    //
    // dispose() is not pure virtual since weak_ptr instantiates a
    // counted_base in its default constructor.
    virtual void dispose() // nothrow
    {
    }
    // destruct() is called when weak_count_ drops to zero.
    virtual void destruct() // nothrow
    {
        delete this;
    }
    void add_ref()
    {
 #ifdef BOOST_HAS_THREADS
        mutex_type::scoped_lock lock(mtx_);
 #endif
        if(use_count_ == 0 && weak_count_ != 0) boost::throw_exception(boost::use_count_is_zero());
        ++use_count_;
        ++weak_count_;
    }
    void release() // nothrow
    {
        long new_use_count;
        long new_weak_count;
        {
 #ifdef BOOST_HAS_THREADS
            mutex_type::scoped_lock lock(mtx_);
 #endif
            new_use_count = --use_count_;
            new_weak_count = --weak_count_;
        }
        if(new_use_count == 0)
        {
            dispose();
        }
        if(new_weak_count == 0)
        {
            destruct();
        }
    }
    void weak_add_ref() // nothrow
    {
 #ifdef BOOST_HAS_THREADS
        mutex_type::scoped_lock lock(mtx_);
 #endif
        ++weak_count_;
    }
    void weak_release() // nothrow
    {
        long new_weak_count;
        {
 #ifdef BOOST_HAS_THREADS
            mutex_type::scoped_lock lock(mtx_);
 #endif
            new_weak_count = --weak_count_;
        }
        if(new_weak_count == 0)
        {
            destruct();
        }
    }
    long use_count() const // nothrow
    {
 #ifdef BOOST_HAS_THREADS
        mutex_type::scoped_lock lock(mtx_);
 #endif
        return use_count_;
    }
 private:
    counted_base(counted_base const &);
    counted_base & operator= (counted_base const &);
    // inv: use_count_ <= weak_count_
    long use_count_;
    long weak_count_;
 #ifdef BOOST_HAS_THREADS
    mutable mutex_type mtx_;
 #endif
 };
 inline void intrusive_ptr_add_ref(counted_base * p)
 {
    p->add_ref();
 }
 inline void intrusive_ptr_release(counted_base * p)
 {
    p->release();
 }
 namespace detail
 {
 //
 // Borland's Codeguard trips up over the -Vx- option here:
 //
 #ifdef __CODEGUARD__
 #pragma option push -Vx-
 #endif
 template<class P, class D> class counted_base_impl: public counted_base
 {
 private:
    P ptr; // copy constructor must not throw
    D del; // copy constructor must not throw
    counted_base_impl(counted_base_impl const &);
    counted_base_impl & operator= (counted_base_impl const &);
 public:
    // pre: initial_use_count <= initial_weak_count, d(p) must not throw
    counted_base_impl(P p, D d, long initial_use_count, long initial_weak_count):
        counted_base(initial_use_count, initial_weak_count), ptr(p), del(d)
    {
    }
    virtual void dispose() // nothrow
    {
        del(ptr);
    }
 };
 class weak_count;
 class shared_count
 {
 private:
    counted_base * pi_;
    friend class weak_count;
    template<class P, class D> shared_count(P, D, counted_base const *);
 public:
    shared_count(): pi_(new counted_base(1, 1))
    {
    }
    explicit shared_count(counted_base * pi): pi_(pi) // never throws
    {
        pi_->add_ref();
    }
    template<class P, class D> shared_count(P p, D d, void const * = 0): pi_(0)
    {
 #ifndef BOOST_NO_EXCEPTIONS
        try
        {
            pi_ = new counted_base_impl<P, D>(p, d, 1, 1);
        }
        catch(...)
        {
            d(p); // delete p
            throw;
        }
 #else
        pi_ = new counted_base_impl<P, D>(p, d, 1, 1);
        if(pi_ == 0)
        {
            d(p); // delete p
            boost::throw_exception(std::bad_alloc());
        }
 #endif
    }
    template<class P, class D> shared_count(P, D, counted_base * pi): pi_(pi)
    {
        pi_->add_ref();
    }
 #ifndef BOOST_NO_AUTO_PTR
    // auto_ptr<Y> is special cased to provide the strong guarantee
    template<typename Y>
    explicit shared_count(std::auto_ptr<Y> & r): pi_(new counted_base_impl< Y *, checked_deleter<Y> >(r.get(), checked_deleter<Y>(), 1, 1))
    {
        r.release();
    }
 #endif 
    ~shared_count() // nothrow
    {
        pi_->release();
    }
    shared_count(shared_count const & r): pi_(r.pi_) // nothrow
    {
        pi_->add_ref();
    }
    explicit shared_count(weak_count const & r); // throws use_count_is_zero when r.use_count() == 0
    shared_count & operator= (shared_count const & r) // nothrow
    {
        counted_base * tmp = r.pi_;
        tmp->add_ref();
        pi_->release();
        pi_ = tmp;
        return *this;
    }
    void swap(shared_count & r) // nothrow
    {
        counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }
    long use_count() const // nothrow
    {
        return pi_->use_count();
    }
    bool unique() const // nothrow
    {
        return pi_->use_count() == 1;
    }
    friend inline bool operator==(shared_count const & a, shared_count const & b)
    {
        return a.pi_ == b.pi_;
    }
    friend inline bool operator<(shared_count const & a, shared_count const & b)
    {
        return std::less<counted_base *>()(a.pi_, b.pi_);
    }
 };
 #ifdef __CODEGUARD__
 #pragma option pop
 #endif
 class weak_count
 {
 private:
    counted_base * pi_;
    friend class shared_count;
 public:
    weak_count(): pi_(new counted_base(0, 1)) // can throw
    {
    }
    weak_count(shared_count const & r): pi_(r.pi_) // nothrow
    {
        pi_->weak_add_ref();
    }
    weak_count(weak_count const & r): pi_(r.pi_) // nothrow
    {
        pi_->weak_add_ref();
    }
    ~weak_count() // nothrow
    {
        pi_->weak_release();
    }
    weak_count & operator= (shared_count const & r) // nothrow
    {
        counted_base * tmp = r.pi_;
        tmp->weak_add_ref();
        pi_->weak_release();
        pi_ = tmp;
        return *this;
    }
    weak_count & operator= (weak_count const & r) // nothrow
    {
        counted_base * tmp = r.pi_;
        tmp->weak_add_ref();
        pi_->weak_release();
        pi_ = tmp;
        return *this;
    }
    void swap(weak_count & r) // nothrow
    {
        counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }
    long use_count() const // nothrow
    {
        return pi_->use_count();
    }
    friend inline bool operator==(weak_count const & a, weak_count const & b)
    {
        return a.pi_ == b.pi_;
    }
    friend inline bool operator<(weak_count const & a, weak_count const & b)
    {
        return std::less<counted_base *>()(a.pi_, b.pi_);
    }
 };
 inline shared_count::shared_count(weak_count const & r): pi_(r.pi_)
 {
    pi_->add_ref();
 }
 } // namespace detail
 } // namespace boost
 #ifdef __BORLANDC__
 # pragma warn .8027     // Functions containing try are not expanded inline
 # pragma warn .8026     // Functions with excep. spec. are not expanded inline
 #endif
 #endif  // #ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/shared_ptr_nmt.hpp
+++ b/include/boost/smart_ptr/detail/shared_ptr_nmt.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_SMART_PTR_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED
+#ifndef BOOST_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED
+#define BOOST_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED
 //
 //  detail/shared_ptr_nmt.hpp - shared_ptr.hpp without member templates
@@ -7,9 +7,10 @@
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
 //  Copyright (c) 2001, 2002 Peter Dimov
 //
-//  Distributed under the Boost Software License, Version 1.0. (See
+//  Permission to copy, use, modify, sell and distribute this software
-//  accompanying file LICENSE_1_0.txt or copy at
+//  is granted provided this copyright notice appears in all copies.
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 //  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
 //
@@ -17,7 +18,7 @@
 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/throw_exception.hpp>
-#include <boost/smart_ptr/detail/atomic_count.hpp>
+#include <boost/detail/atomic_count.hpp>
 #ifndef BOOST_NO_AUTO_PTR
 # include <memory>          // for std::auto_ptr
@@ -179,4 +180,4 @@ template<class T> inline T * get_pointer(shared_ptr<T> const & p)
 } // namespace boost
-#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED
+#endif  // #ifndef BOOST_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED
--- a/include/boost/detail/sp_typeinfo.hpp
+++ b/include/boost/detail/sp_typeinfo.hpp
@@ -1,83 +0,0 @@
 #ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
 #define BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //  detail/sp_typeinfo.hpp
 //
 //  Copyright 2007 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)
 #include <boost/config.hpp>
 #if defined( BOOST_NO_TYPEID )
 namespace boost
 {
 namespace detail
 {
 typedef void* sp_typeinfo;
 template<class T> struct sp_typeid_
 {
    static char v_;
 };
 template<class T> char sp_typeid_< T >::v_;
 template<class T> struct sp_typeid_< T const >: sp_typeid_< T >
 {
 };
 template<class T> struct sp_typeid_< T volatile >: sp_typeid_< T >
 {
 };
 template<class T> struct sp_typeid_< T const volatile >: sp_typeid_< T >
 {
 };
 } // namespace detail
 } // namespace boost
 #define BOOST_SP_TYPEID(T) (&boost::detail::sp_typeid_<T>::v_)
 #else
 #include <typeinfo>
 namespace boost
 {
 namespace detail
 {
 #if defined( BOOST_NO_STD_TYPEINFO )
 typedef ::type_info sp_typeinfo;
 #else
 typedef std::type_info sp_typeinfo;
 #endif
 } // namespace detail
 } // namespace boost
 #define BOOST_SP_TYPEID(T) typeid(T)
 #endif
 #endif  // #ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
--- a/include/boost/detail/winapi.hpp
+++ b/include/boost/detail/winapi.hpp
@@ -0,0 +1,106 @@
 #ifndef BOOST_DETAIL_WINAPI_HPP_INCLUDED
 #define BOOST_DETAIL_WINAPI_HPP_INCLUDED
 #if _MSC_VER >= 1020
 #pragma once
 #endif
 //
 //  boost/detail/winapi.hpp - a lightweight version of <windows.h>
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
 //  Permission to copy, use, modify, sell and distribute this software
 //  is granted provided this copyright notice appears in all copies.
 //  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 namespace boost
 {
 namespace detail
 {
 namespace winapi
 {
 typedef long long_type;
 typedef unsigned long dword_type;
 typedef void * handle_type;
 #if defined(_WIN64)
 typedef __int64 int_ptr_type;
 typedef unsigned __int64 uint_ptr_type;
 typedef __int64 long_ptr_type;
 typedef unsigned __int64 ulong_ptr_type;
 #else
 typedef int int_ptr_type;
 typedef unsigned int uint_ptr_type;
 typedef long long_ptr_type;
 typedef unsigned long ulong_ptr_type;
 #endif
 struct critical_section
 {
    struct critical_section_debug * DebugInfo;
    long_type LockCount;
    long_type RecursionCount;
    handle_type OwningThread;
    handle_type LockSemaphore;
    ulong_ptr_type SpinCount;
 };
 #if defined(_WIN64)
 // Intel 6.0 on Win64 version, posted by Tim Fenders to [boost-users]
 extern "C" long_type __cdecl _InterlockedIncrement(long_type volatile *);
 extern "C" long_type __cdecl _InterlockedDecrement(long_type volatile *);
 extern "C" long_type __cdecl _InterlockedExchange(long_type volatile *, long_type);
 #pragma intrinsic(_InterlockedIncrement)
 #pragma intrinsic(_InterlockedDecrement)
 #pragma intrinsic(_InterlockedExchange)
 inline long_type InterlockedIncrement(long_type volatile * lp)
 { 
    return _InterlockedIncrement(lp);
 }
 inline long_type InterlockedDecrement(long_type volatile* lp)
 { 
    return _InterlockedDecrement(lp);
 }
 inline long_type InterlockedExchange(long_type volatile* lp, long_type l)
 {
    return _InterlockedExchange(lp, l);
 }
 #else
 extern "C" __declspec(dllimport) long_type __stdcall InterlockedIncrement(long_type volatile *);
 extern "C" __declspec(dllimport) long_type __stdcall InterlockedDecrement(long_type volatile *);
 extern "C" __declspec(dllimport) long_type __stdcall InterlockedExchange(long_type volatile *, long_type);
 #endif
 extern "C" __declspec(dllimport) void __stdcall Sleep(dword_type);
 extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(critical_section *);
 extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(critical_section *);
 extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(critical_section *);
 extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(critical_section *);
 } // namespace winapi
 } // namespace detail
 } // namespace boost
 #endif // #ifndef BOOST_DETAIL_WINAPI_HPP_INCLUDED
--- a/include/boost/enable_shared_from_this.hpp
+++ b/include/boost/enable_shared_from_this.hpp
@@ -1,18 +0,0 @@
 #ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
 #define BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
 //
 //  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
 //
 //  http://www.boost.org/libs/smart_ptr/enable_shared_from_this.html
 //
 #include <boost/smart_ptr/enable_shared_from_this.hpp>
 #endif  // #ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
--- a/include/boost/get_pointer.hpp
+++ b/include/boost/get_pointer.hpp
@@ -1,33 +0,0 @@
 // Copyright Peter Dimov and David Abrahams 2002.
 // 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)
 #ifndef GET_POINTER_DWA20021219_HPP
 # define GET_POINTER_DWA20021219_HPP
 // In order to avoid circular dependencies with Boost.TR1
 // we make sure that our include of <memory> doesn't try to
 // pull in the TR1 headers: that's why we use this header 
 // rather than including <memory> directly:
 # include <boost/config/no_tr1/memory.hpp>  // std::auto_ptr
 namespace boost { 
 // get_pointer(p) extracts a ->* capable pointer from p
 template<class T> T * get_pointer(T * p)
 {
    return p;
 }
 // get_pointer(shared_ptr<T> const & p) has been moved to shared_ptr.hpp
 template<class T> T * get_pointer(std::auto_ptr<T> const& p)
 {
    return p.get();
 }
 } // namespace boost
 #endif // GET_POINTER_DWA20021219_HPP
--- a/include/boost/intrusive_ptr.hpp
+++ b/include/boost/intrusive_ptr.hpp
@@ -6,13 +6,197 @@
 //
 //  Copyright (c) 2001, 2002 Peter Dimov
 //
-//  Distributed under the Boost Software License, Version 1.0.
+//  Permission to copy, use, modify, sell and distribute this software
-//  See accompanying file LICENSE_1_0.txt or copy at
+//  is granted provided this copyright notice appears in all copies.
-//  http://www.boost.org/LICENSE_1_0.txt
+//  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 //  See http://www.boost.org/libs/smart_ptr/intrusive_ptr.html for documentation.
 //
-#include <boost/smart_ptr/intrusive_ptr.hpp>
+#ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
 # pragma warning(push)
 # pragma warning(disable:4284) // odd return type for operator->
 #endif
 #include <functional> // std::less
 namespace boost
 {
 //
 //  intrusive_ptr
 //
 //  A smart pointer that uses intrusive reference counting.
 //
 //  Relies on unqualified calls to
 //  
 //      void intrusive_ptr_add_ref(T * p);
 //      void intrusive_ptr_release(T * p);
 //
 //          (p != 0)
 //
 //  The object is responsible for destroying itself.
 //
 template<class T> class intrusive_ptr
 {
 private:
    typedef intrusive_ptr this_type;
 public:
    intrusive_ptr(): p_(0)
    {
    }
    intrusive_ptr(T * p): p_(p)
    {
        if(p_ != 0) intrusive_ptr_add_ref(p_);
    }
    ~intrusive_ptr()
    {
        if(p_ != 0) intrusive_ptr_release(p_);
    }
 #if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
    template<class U> intrusive_ptr(intrusive_ptr<U> const & rhs): p_(rhs.get())
    {
        if(p_ != 0) intrusive_ptr_add_ref(p_);
    }
 #endif
    intrusive_ptr(intrusive_ptr const & rhs): p_(rhs.p_)
    {
        if(p_ != 0) intrusive_ptr_add_ref(p_);
    }
 #if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
    template<class U> intrusive_ptr & operator=(intrusive_ptr<U> const & rhs)
    {
        this_type(rhs).swap(*this);
        return *this;
    }
 #endif
    intrusive_ptr & operator=(intrusive_ptr const & rhs)
    {
        this_type(rhs).swap(*this);
        return *this;
    }
    intrusive_ptr & operator=(T * rhs)
    {
        this_type(rhs).swap(*this);
        return *this;
    }
    void swap(intrusive_ptr & rhs)
    {
        T * tmp = p_;
        p_ = rhs.p_;
        rhs.p_ = tmp;
    }
    T * get() const
    {
        return p_;
    }
    T & operator*() const
    {
        return *p_;
    }
    T * operator->() const
    {
        return p_;
    }
    bool empty() const
    {
        return p_ == 0;
    }
    typedef bool (intrusive_ptr::*bool_type) () const;
    operator bool_type () const
    {
        return p_ == 0? 0: &intrusive_ptr::empty;
    }
 private:
    T * p_;
 };
 template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs)
 {
    lhs.swap(rhs);
 }
 template<class T, class U> intrusive_ptr<T> shared_dynamic_cast(intrusive_ptr<U> const & p)
 {
    return dynamic_cast<T *>(p.get());
 }
 template<class T, class U> intrusive_ptr<T> shared_static_cast(intrusive_ptr<U> const & p)
 {
    return static_cast<T *>(p.get());
 }
 template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b)
 {
    return a.get() == b.get();
 }
 template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b)
 {
    return a.get() != b.get();
 }
 template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
 {
    return std::less<T *>(a.get(), b.get());
 }
 template<class T> inline bool operator==(intrusive_ptr<T> const & a, T * b)
 {
    return a.get() == b;
 }
 template<class T> inline bool operator!=(intrusive_ptr<T> const & a, T * b)
 {
    return a.get() != b;
 }
 template<class T> inline bool operator==(T * a, intrusive_ptr<T> const & b)
 {
    return a == b.get();
 }
 template<class T> inline bool operator!=(T * a, intrusive_ptr<T> const & b)
 {
    return a != b.get();
 }
 // mem_fn support
 template<class T> T * get_pointer(intrusive_ptr<T> const & p)
 {
    return p.get();
 }
 } // namespace boost
 #ifdef BOOST_MSVC
 # pragma warning(pop)
 #endif    
 #endif  // #ifndef BOOST_INTRUSIVE_PTR_HPP_INCLUDED
--- a/include/boost/make_shared.hpp
+++ b/include/boost/make_shared.hpp
@@ -1,17 +0,0 @@
 #ifndef BOOST_MAKE_SHARED_HPP_INCLUDED
 #define BOOST_MAKE_SHARED_HPP_INCLUDED
 //  make_shared.hpp
 //
 //  Copyright (c) 2007, 2008 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
 //
 //  See http://www.boost.org/libs/smart_ptr/make_shared.html
 //  for documentation.
 #include <boost/smart_ptr/make_shared.hpp>
 #endif // #ifndef BOOST_MAKE_SHARED_HPP_INCLUDED
--- a/include/boost/memory_order.hpp
+++ b/include/boost/memory_order.hpp
@@ -1,35 +0,0 @@
 #ifndef BOOST_MEMORY_ORDER_HPP_INCLUDED
 #define BOOST_MEMORY_ORDER_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //  boost/memory_order.hpp
 //
 //  Defines enum boost::memory_order per the C++0x working draft
 //
 //  Copyright (c) 2008 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)
 namespace boost
 {
 enum memory_order
 {
    memory_order_relaxed = 0,
    memory_order_acquire = 1,
    memory_order_release = 2,
    memory_order_acq_rel = 3, // acquire | release
    memory_order_seq_cst = 7  // acq_rel | 4
 };
 } // namespace boost
 #endif // #ifndef BOOST_MEMORY_ORDER_HPP_INCLUDED
--- a/include/boost/pointer_cast.hpp
+++ b/include/boost/pointer_cast.hpp
@@ -1,45 +0,0 @@
 //////////////////////////////////////////////////////////////////////////////
 //
 // (C) Copyright Ion Gaztanaga 2005. 
 // 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)
 //
 //////////////////////////////////////////////////////////////////////////////
 #ifndef BOOST_POINTER_CAST_HPP
 #define BOOST_POINTER_CAST_HPP
 namespace boost { 
 //static_pointer_cast overload for raw pointers
 template<class T, class U>
 inline T* static_pointer_cast(U *ptr)
 {  
   return static_cast<T*>(ptr);
 }
 //dynamic_pointer_cast overload for raw pointers
 template<class T, class U>
 inline T* dynamic_pointer_cast(U *ptr)
 {  
   return dynamic_cast<T*>(ptr);
 }
 //const_pointer_cast overload for raw pointers
 template<class T, class U>
 inline T* const_pointer_cast(U *ptr)
 {  
   return const_cast<T*>(ptr);
 }
 //reinterpret_pointer_cast overload for raw pointers
 template<class T, class U>
 inline T* reinterpret_pointer_cast(U *ptr)
 {  
   return reinterpret_cast<T*>(ptr);
 }
 } // namespace boost
 #endif   //BOOST_POINTER_CAST_HPP
--- a/include/boost/pointer_to_other.hpp
+++ b/include/boost/pointer_to_other.hpp
@@ -1,55 +0,0 @@
 #ifndef BOOST_POINTER_TO_OTHER_HPP_INCLUDED
 #define BOOST_POINTER_TO_OTHER_HPP_INCLUDED
 //
 //  pointer_to_other.hpp
 //
 //  (C) Copyright Ion Gaztanaga 2005.
 //  Copyright (c) 2005 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)
 //
 //  See http://www.boost.org/libs/smart_ptr/pointer_to_other.html
 //
 namespace boost
 {
 // Defines the same pointer type (raw or smart) to another pointee type
 template<class T, class U>
 struct pointer_to_other;
 template<class T, class U, 
         template<class> class Sp>
 struct pointer_to_other< Sp<T>, U >
 {
   typedef Sp<U> type;
 };
 template<class T, class T2, class U, 
         template<class, class> class Sp>
 struct pointer_to_other< Sp<T, T2>, U >
 {
   typedef Sp<U, T2> type;
 };
 template<class T, class T2, class T3, class U, 
         template<class, class, class> class Sp>
 struct pointer_to_other< Sp<T, T2, T3>, U >
 {
   typedef Sp<U, T2, T3> type;
 };
 template<class T, class U>
 struct pointer_to_other< T*, U >
 {
   typedef U* type;
 };
 } // namespace boost
 #endif // #ifndef BOOST_POINTER_TO_OTHER_HPP_INCLUDED
--- a/include/boost/scoped_array.hpp
+++ b/include/boost/scoped_array.hpp
@@ -4,13 +4,99 @@
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
 //  Copyright (c) 2001, 2002 Peter Dimov
 //
-//  Distributed under the Boost Software License, Version 1.0. (See
+//  Permission to copy, use, modify, sell and distribute this software
-//  accompanying file LICENSE_1_0.txt or copy at
+//  is granted provided this copyright notice appears in all copies.
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
-//  http://www.boost.org/libs/smart_ptr/scoped_array.htm
+//  See http://www.boost.org/libs/smart_ptr/scoped_array.htm for documentation.
 //
-#include <boost/smart_ptr/scoped_array.hpp>
+#include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/config.hpp>   // in case ptrdiff_t not in std
 #include <cstddef>            // for std::ptrdiff_t
 namespace boost
 {
 //  scoped_array extends scoped_ptr to arrays. Deletion of the array pointed to
 //  is guaranteed, either on destruction of the scoped_array or via an explicit
 //  reset(). Use shared_array or std::vector if your needs are more complex.
 template<typename T> class scoped_array // noncopyable
 {
 private:
    T * ptr;
    scoped_array(scoped_array const &);
    scoped_array & operator=(scoped_array const &);
    typedef scoped_array<T> this_type;
 public:
    typedef T element_type;
    explicit scoped_array(T * p = 0) : ptr(p) // never throws
    {
    }
    ~scoped_array() // never throws
    {
        checked_array_delete(ptr);
    }
    void reset(T * p = 0) // never throws
    {
        if (ptr != p)
        {
            checked_array_delete(ptr);
            ptr = p;
        }
    }
    T & operator[](std::ptrdiff_t i) const // never throws
    {
        BOOST_ASSERT(ptr != 0);
        BOOST_ASSERT(i >= 0);
        return ptr[i];
    }
    T * get() const // never throws
    {
        return ptr;
    }
    // implicit conversion to "bool"
    typedef T * (this_type::*unspecified_bool_type)() const;
    operator unspecified_bool_type() const // never throws
    {
        return ptr == 0? 0: &this_type::get;
    }
    bool operator! () const // never throws
    {
        return ptr == 0;
    }
    void swap(scoped_array & b) // never throws
    {
        T * tmp = b.ptr;
        b.ptr = ptr;
        ptr = tmp;
    }
 };
 template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) // never throws
 {
    a.swap(b);
 }
 } // namespace boost
 #endif  // #ifndef BOOST_SCOPED_ARRAY_HPP_INCLUDED
--- a/include/boost/scoped_ptr.hpp
+++ b/include/boost/scoped_ptr.hpp
@@ -4,13 +4,120 @@
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
 //  Copyright (c) 2001, 2002 Peter Dimov
 //
-//  Distributed under the Boost Software License, Version 1.0. (See
+//  Permission to copy, use, modify, sell and distribute this software
-//  accompanying file LICENSE_1_0.txt or copy at
+//  is granted provided this copyright notice appears in all copies.
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
-//  http://www.boost.org/libs/smart_ptr/scoped_ptr.htm
+//  See http://www.boost.org/libs/smart_ptr/scoped_ptr.htm for documentation.
 //
-#include <boost/smart_ptr/scoped_ptr.hpp>
+#include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
 #ifndef BOOST_NO_AUTO_PTR
 # include <memory>          // for std::auto_ptr
 #endif
 namespace boost
 {
 //  scoped_ptr mimics a built-in pointer except that it guarantees deletion
 //  of the object pointed to, either on destruction of the scoped_ptr or via
 //  an explicit reset(). scoped_ptr is a simple solution for simple needs;
 //  use shared_ptr or std::auto_ptr if your needs are more complex.
 template<typename T> class scoped_ptr // noncopyable
 {
 private:
    T * ptr;
    scoped_ptr(scoped_ptr const &);
    scoped_ptr & operator=(scoped_ptr const &);
    typedef scoped_ptr<T> this_type;
 public:
    typedef T element_type;
    explicit scoped_ptr(T * p = 0): ptr(p) // never throws
    {
    }
 #ifndef BOOST_NO_AUTO_PTR
    explicit scoped_ptr(std::auto_ptr<T> p): ptr(p.release()) // never throws
    {
    }
 #endif
    ~scoped_ptr() // never throws
    {
        checked_delete(ptr);
    }
    void reset(T * p = 0) // never throws
    {
        if(ptr != p)
        {
            this_type(p).swap(*this);
        }
    }
    T & operator*() const // never throws
    {
        BOOST_ASSERT(ptr != 0);
        return *ptr;
    }
    T * operator->() const // never throws
    {
        BOOST_ASSERT(ptr != 0);
        return ptr;
    }
    T * get() const // never throws
    {
        return ptr;
    }
    // implicit conversion to "bool"
    typedef T * (this_type::*unspecified_bool_type)() const;
    operator unspecified_bool_type() const // never throws
    {
        return ptr == 0? 0: &this_type::get;
    }
    bool operator! () const // never throws
    {
        return ptr == 0;
    }
    void swap(scoped_ptr & b) // never throws
    {
        T * tmp = b.ptr;
        b.ptr = ptr;
        ptr = tmp;
    }
 };
 template<typename T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) // never throws
 {
    a.swap(b);
 }
 // get_pointer(p) is a generic way to say p.get()
 template<typename T> inline T * get_pointer(scoped_ptr<T> const & p)
 {
    return p.get();
 }
 } // namespace boost
 #endif // #ifndef BOOST_SCOPED_PTR_HPP_INCLUDED
--- a/include/boost/shared_array.hpp
+++ b/include/boost/shared_array.hpp
@@ -7,13 +7,150 @@
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
 //  Copyright (c) 2001, 2002 Peter Dimov
 //
-//  Distributed under the Boost Software License, Version 1.0. (See
+//  Permission to copy, use, modify, sell and distribute this software
-//  accompanying file LICENSE_1_0.txt or copy at
+//  is granted provided this copyright notice appears in all copies.
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 //  See http://www.boost.org/libs/smart_ptr/shared_array.htm for documentation.
 //
-#include <boost/smart_ptr/shared_array.hpp>
+#include <boost/config.hpp>   // for broken compiler workarounds
 #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
 #include <boost/detail/shared_array_nmt.hpp>
 #else
 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/detail/shared_count.hpp>
 #include <cstddef>            // for std::ptrdiff_t
 #include <algorithm>          // for std::swap
 #include <functional>         // for std::less
 namespace boost
 {
 //
 //  shared_array
 //
 //  shared_array extends shared_ptr to arrays.
 //  The array pointed to is deleted when the last shared_array pointing to it
 //  is destroyed or reset.
 //
 template<typename T> class shared_array
 {
 private:
    // Borland 5.5.1 specific workarounds
    typedef checked_array_deleter<T> deleter;
    typedef shared_array<T> this_type;
 public:
    typedef T element_type;
    explicit shared_array(T * p = 0): px(p), pn(p, deleter())
    {
    }
    //
    // Requirements: D's copy constructor must not throw
    //
    // shared_array will release p by calling d(p)
    //
    template<typename D> shared_array(T * p, D d): px(p), pn(p, d)
    {
    }
 //  generated copy constructor, assignment, destructor are fine
    void reset(T * p = 0)
    {
        BOOST_ASSERT(p == 0 || p != px);
        this_type(p).swap(*this);
    }
    template <typename D> void reset(T * p, D d)
    {
        this_type(p, d).swap(*this);
    }
    T & operator[] (std::ptrdiff_t i) const // never throws
    {
        BOOST_ASSERT(px != 0);
        BOOST_ASSERT(i >= 0);
        return px[i];
    }
    T * get() const // never throws
    {
        return px;
    }
    // implicit conversion to "bool"
    typedef T * (this_type::*unspecified_bool_type)() const;
    operator unspecified_bool_type() const // never throws
    {
        return px == 0? 0: &this_type::get;
    }
    bool operator! () const // never throws
    {
        return px == 0;
    }
    bool unique() const // never throws
    {
        return pn.unique();
    }
    long use_count() const // never throws
    {
        return pn.use_count();
    }
    void swap(shared_array<T> & other) // never throws
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }
 private:
    T * px;                     // contained pointer
    detail::shared_count pn;    // reference counter
 };  // shared_array
 template<typename T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) // never throws
 {
    return a.get() == b.get();
 }
 template<typename T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) // never throws
 {
    return a.get() != b.get();
 }
 template<typename T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) // never throws
 {
    return std::less<T*>()(a.get(), b.get());
 }
 template<typename T> void swap(shared_array<T> & a, shared_array<T> & b) // never throws
 {
    a.swap(b);
 }
 } // namespace boost
 #endif  // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
 #endif  // #ifndef BOOST_SHARED_ARRAY_HPP_INCLUDED
--- a/include/boost/shared_ptr.hpp
+++ b/include/boost/shared_ptr.hpp
@@ -5,15 +5,352 @@
 //  shared_ptr.hpp
 //
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
-//  Copyright (c) 2001-2008 Peter Dimov
+//  Copyright (c) 2001, 2002 Peter Dimov
 //
-//  Distributed under the Boost Software License, Version 1.0. (See
+//  Permission to copy, use, modify, sell and distribute this software
-//  accompanying file LICENSE_1_0.txt or copy at
+//  is granted provided this copyright notice appears in all copies.
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 //  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
 //
-#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/config.hpp>   // for broken compiler workarounds
 #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
 #include <boost/detail/shared_ptr_nmt.hpp>
 #else
 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/throw_exception.hpp>
 #include <boost/detail/shared_count.hpp>
 #include <memory>             // for std::auto_ptr
 #include <algorithm>          // for std::swap
 #include <functional>         // for std::less
 #include <typeinfo>           // for std::bad_cast
 #ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
 # pragma warning(push)
 # pragma warning(disable:4284) // odd return type for operator->
 #endif
 namespace boost
 {
 namespace detail
 {
 struct static_cast_tag {};
 struct dynamic_cast_tag {};
 struct polymorphic_cast_tag {};
 template<typename T> struct shared_ptr_traits
 {
    typedef T & reference;
 };
 template<> struct shared_ptr_traits<void>
 {
    typedef void reference;
 };
 #if !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)
 template<> struct shared_ptr_traits<void const>
 {
    typedef void reference;
 };
 #endif
 } // namespace detail
 //
 //  shared_ptr
 //
 //  An enhanced relative of scoped_ptr with reference counted copy semantics.
 //  The object pointed to is deleted when the last shared_ptr pointing to it
 //  is destroyed or reset.
 //
 template<typename T> class weak_ptr;
 template<typename T> class intrusive_ptr;
 template<typename T> class shared_ptr
 {
 private:
    // Borland 5.5.1 specific workarounds
 //  typedef checked_deleter<T> deleter;
    typedef shared_ptr<T> this_type;
 public:
    typedef T element_type;
    typedef T value_type;
    shared_ptr(): px(0), pn()
    {
    }
    template<typename Y>
    explicit shared_ptr(Y * p): px(p), pn(p, checked_deleter<Y>(), p) // Y must be complete
    {
    }
    //
    // Requirements: D's copy constructor must not throw
    //
    // shared_ptr will release p by calling d(p)
    //
    template<typename Y, typename D> shared_ptr(Y * p, D d): px(p), pn(p, d)
    {
    }
 //  generated copy constructor, assignment, destructor are fine
    template<typename Y>
    explicit shared_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // may throw
    {
    }
    template<typename Y>
    shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
    {
    }
    template<typename Y>
    shared_ptr(intrusive_ptr<Y> const & r): px(r.get()), pn(r.get()) // never throws
    {
    }
    template<typename Y>
    shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
    {
    }
    template<typename Y>
    shared_ptr(shared_ptr<Y> const & r, detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
    {
        if (px == 0) // need to allocate new counter -- the cast failed
        {
            pn = detail::shared_count();
        }
    }
    template<typename Y>
    shared_ptr(shared_ptr<Y> const & r, detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
    {
        if (px == 0)
        {
            boost::throw_exception(std::bad_cast());
        }
    }
 #ifndef BOOST_NO_AUTO_PTR
    template<typename Y>
    explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn(r)
    {
    }
 #endif
 #if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
    template<typename Y>
    shared_ptr & operator=(shared_ptr<Y> const & r) // never throws
    {
        px = r.px;
        pn = r.pn; // shared_count::op= doesn't throw
        return *this;
    }
 #endif
 #ifndef BOOST_NO_AUTO_PTR
    template<typename Y>
    shared_ptr & operator=(std::auto_ptr<Y> & r)
    {
        this_type(r).swap(*this);
        return *this;
    }
 #endif
    void reset()
    {
        this_type().swap(*this);
    }
    template<typename Y> void reset(Y * p) // Y must be complete
    {
        BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors
        this_type(p).swap(*this);
    }
    template<typename Y, typename D> void reset(Y * p, D d)
    {
        this_type(p, d).swap(*this);
    }
    typename detail::shared_ptr_traits<T>::reference operator* () const // never throws
    {
        BOOST_ASSERT(px != 0);
        return *px;
    }
    T * operator-> () const // never throws
    {
        BOOST_ASSERT(px != 0);
        return px;
    }
    T * get() const // never throws
    {
        return px;
    }
    // implicit conversion to "bool"
    typedef T * (this_type::*unspecified_bool_type)() const;
    operator unspecified_bool_type() const // never throws
    {
        return px == 0? 0: &this_type::get;
    }
    bool operator! () const // never throws
    {
        return px == 0;
    }
    bool unique() const // never throws
    {
        return pn.unique();
    }
    long use_count() const // never throws
    {
        return pn.use_count();
    }
    void swap(shared_ptr<T> & other) // never throws
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }
 // Tasteless as this may seem, making all members public allows member templates
 // to work in the absence of member template friends. (Matthew Langston)
 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 private:
    template<typename Y> friend class shared_ptr;
    template<typename Y> friend class weak_ptr;
 #endif
    T * px;                     // contained pointer
    detail::shared_count pn;    // reference counter
 };  // shared_ptr
 template<typename T, typename U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
 {
    return a.get() == b.get();
 }
 template<typename T, typename U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
 {
    return a.get() != b.get();
 }
 #if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
 // Resolve the ambiguity between our op!= and the one in rel_ops
 template<typename T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b)
 {
    return a.get() != b.get();
 }
 #endif
 template<typename T> inline bool operator<(shared_ptr<T> const & a, shared_ptr<T> const & b)
 {
    return std::less<T*>()(a.get(), b.get());
 }
 template<typename T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
 {
    a.swap(b);
 }
 template<typename T, typename U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
 {
    return shared_ptr<T>(r, detail::static_cast_tag());
 }
 template<typename T, typename U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
 {
    return shared_ptr<T>(r, detail::dynamic_cast_tag());
 }
 template<typename T, typename U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
 {
    return shared_ptr<T>(r, detail::polymorphic_cast_tag());
 }
 template<typename T, typename U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
 {
    BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get());
    return shared_static_cast<T>(r);
 }
 // get_pointer() enables boost::mem_fn to recognize shared_ptr
 template<typename T> inline T * get_pointer(shared_ptr<T> const & p)
 {
    return p.get();
 }
 // shared_from_this() creates a shared_ptr from a raw pointer (usually 'this')
 namespace detail
 {
 inline void sp_assert_counted_base(boost::counted_base const *)
 {
 }
 template<class T> inline T * sp_remove_const(T const * p)
 {
    return const_cast<T *>(p);
 }
 } // namespace detail
 template<class T> shared_ptr<T> shared_from_this(T * p)
 {
    detail::sp_assert_counted_base(p);
    return shared_ptr<T>(detail::sp_remove_const(p));
 }
 } // namespace boost
 #ifdef BOOST_MSVC
 # pragma warning(pop)
 #endif    
 #endif  // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
 #endif  // #ifndef BOOST_SHARED_PTR_HPP_INCLUDED
--- a/include/boost/smart_ptr.hpp
+++ b/include/boost/smart_ptr.hpp
@@ -1,25 +1,9 @@
-//
+//  Boost smart_ptr.hpp header file  -----------------------------------------//
 //  smart_ptr.hpp
 //
 //  For convenience, this header includes the rest of the smart
 //  pointer library headers.
 //
 //  Copyright (c) 2003 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)
 //
 //  http://www.boost.org/libs/smart_ptr/smart_ptr.htm
 //
-#include <boost/config.hpp>
+// For compatibility, this header includes the header for the four "classic"
 // smart pointer class templates.
 #include <boost/scoped_ptr.hpp> 
 #include <boost/scoped_array.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/shared_array.hpp>
 #if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
 # include <boost/weak_ptr.hpp>
 # include <boost/intrusive_ptr.hpp>
 # include <boost/enable_shared_from_this.hpp>
 #endif
--- a/include/boost/smart_ptr/bad_weak_ptr.hpp
+++ b/include/boost/smart_ptr/bad_weak_ptr.hpp
@@ -1,59 +0,0 @@
 #ifndef BOOST_SMART_PTR_BAD_WEAK_PTR_HPP_INCLUDED
 #define BOOST_SMART_PTR_BAD_WEAK_PTR_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  boost/smart_ptr/bad_weak_ptr.hpp
 //
 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
 //
 // 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)
 //
 #include <exception>
 #ifdef __BORLANDC__
 # pragma warn -8026     // Functions with excep. spec. are not expanded inline
 #endif
 namespace boost
 {
 // The standard library that comes with Borland C++ 5.5.1, 5.6.4
 // defines std::exception and its members as having C calling
 // convention (-pc). When the definition of bad_weak_ptr
 // is compiled with -ps, the compiler issues an error.
 // Hence, the temporary #pragma option -pc below.
 #if defined(__BORLANDC__) && __BORLANDC__ <= 0x564
 # pragma option push -pc
 #endif
 class bad_weak_ptr: public std::exception
 {
 public:
    virtual char const * what() const throw()
    {
        return "tr1::bad_weak_ptr";
    }
 };
 #if defined(__BORLANDC__) && __BORLANDC__ <= 0x564
 # pragma option pop
 #endif
 } // namespace boost
 #ifdef __BORLANDC__
 # pragma warn .8026     // Functions with excep. spec. are not expanded inline
 #endif
 #endif  // #ifndef BOOST_SMART_PTR_BAD_WEAK_PTR_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/atomic_count.hpp
+++ b/include/boost/smart_ptr/detail/atomic_count.hpp
@@ -1,119 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  boost/detail/atomic_count.hpp - thread/SMP safe reference counter
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //
 // 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)
 //
 //  typedef <implementation-defined> boost::detail::atomic_count;
 //
 //  atomic_count a(n);
 //
 //    (n is convertible to long)
 //
 //    Effects: Constructs an atomic_count with an initial value of n
 //
 //  a;
 //
 //    Returns: (long) the current value of a
 //
 //  ++a;
 //
 //    Effects: Atomically increments the value of a
 //    Returns: (long) the new value of a
 //
 //  --a;
 //
 //    Effects: Atomically decrements the value of a
 //    Returns: (long) the new value of a
 //
 //    Important note: when --a returns zero, it must act as a
 //      read memory barrier (RMB); i.e. the calling thread must
 //      have a synchronized view of the memory
 //
 //    On Intel IA-32 (x86) memory is always synchronized, so this
 //      is not a problem.
 //
 //    On many architectures the atomic instructions already act as
 //      a memory barrier.
 //
 //    This property is necessary for proper reference counting, since
 //      a thread can update the contents of a shared object, then
 //      release its reference, and another thread may immediately
 //      release the last reference causing object destruction.
 //
 //    The destructor needs to have a synchronized view of the
 //      object to perform proper cleanup.
 //
 //    Original example by Alexander Terekhov:
 //
 //    Given:
 //
 //    - a mutable shared object OBJ;
 //    - two threads THREAD1 and THREAD2 each holding 
 //      a private smart_ptr object pointing to that OBJ.
 //
 //    t1: THREAD1 updates OBJ (thread-safe via some synchronization)
 //      and a few cycles later (after "unlock") destroys smart_ptr;
 //
 //    t2: THREAD2 destroys smart_ptr WITHOUT doing any synchronization 
 //      with respect to shared mutable object OBJ; OBJ destructors
 //      are called driven by smart_ptr interface...
 //
 #include <boost/config.hpp>
 #include <boost/smart_ptr/detail/sp_has_sync.hpp>
 #ifndef BOOST_HAS_THREADS
 namespace boost
 {
 namespace detail
 {
 typedef long atomic_count;
 }
 }
 #elif defined(BOOST_AC_USE_PTHREADS)
 #  include <boost/smart_ptr/detail/atomic_count_pthreads.hpp>
 #elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) )
 #  include <boost/smart_ptr/detail/atomic_count_gcc_x86.hpp>
 #elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 #  include <boost/smart_ptr/detail/atomic_count_win32.hpp>
 #elif defined( BOOST_SP_HAS_SYNC )
 #  include <boost/smart_ptr/detail/atomic_count_sync.hpp>
 #elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
 #  include <boost/smart_ptr/detail/atomic_count_gcc.hpp>
 #elif defined(BOOST_HAS_PTHREADS)
 #  define BOOST_AC_USE_PTHREADS
 #  include <boost/smart_ptr/detail/atomic_count_pthreads.hpp>
 #else
 // Use #define BOOST_DISABLE_THREADS to avoid the error
 #error Unrecognized threading platform
 #endif
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/atomic_count_gcc.hpp
+++ b/include/boost/smart_ptr/detail/atomic_count_gcc.hpp
@@ -1,72 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED
 //
 //  boost/detail/atomic_count_gcc.hpp
 //
 //  atomic_count for GNU libstdc++ v3
 //
 //  http://gcc.gnu.org/onlinedocs/porting/Thread-safety.html
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //  Copyright (c) 2002 Lars Gullik Bj<42>nnes <larsbj@lyx.org>
 //  Copyright 2003-2005 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)
 //
 #if __GNUC__ * 100 + __GNUC_MINOR__ >= 402
 # include <ext/atomicity.h> 
 #else 
 # include <bits/atomicity.h>
 #endif
 namespace boost
 {
 namespace detail
 {
 #if defined(__GLIBCXX__) // g++ 3.4+
 using __gnu_cxx::__atomic_add;
 using __gnu_cxx::__exchange_and_add;
 #endif
 class atomic_count
 {
 public:
    explicit atomic_count( long v ) : value_( v ) {}
    long operator++()
    {
        return __exchange_and_add( &value_, +1 ) + 1;
    }
    long operator--()
    {
        return __exchange_and_add( &value_, -1 ) - 1;
    }
    operator long() const
    {
        return __exchange_and_add( &value_, 0 );
    }
 private:
    atomic_count(atomic_count const &);
    atomic_count & operator=(atomic_count const &);
    mutable _Atomic_word value_;
 };
 } // namespace detail
 } // namespace boost
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/atomic_count_gcc_x86.hpp
+++ b/include/boost/smart_ptr/detail/atomic_count_gcc_x86.hpp
@@ -1,77 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_GCC_X86_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_GCC_X86_HPP_INCLUDED
 //
 //  boost/detail/atomic_count_gcc_x86.hpp
 //
 //  atomic_count for g++ on 486+/AMD64
 //
 //  Copyright 2007 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)
 //
 namespace boost
 {
 namespace detail
 {
 class atomic_count
 {
 public:
    explicit atomic_count( long v ) : value_( static_cast< int >( v ) ) {}
    long operator++()
    {
        return atomic_exchange_and_add( &value_, +1 ) + 1;
    }
    long operator--()
    {
        return atomic_exchange_and_add( &value_, -1 ) - 1;
    }
    operator long() const
    {
        return atomic_exchange_and_add( &value_, 0 );
    }
 private:
    atomic_count(atomic_count const &);
    atomic_count & operator=(atomic_count const &);
    mutable int value_;
 private:
    static int atomic_exchange_and_add( int * pw, int dv )
    {
        // int r = *pw;
        // *pw += dv;
        // return r;
        int r;
        __asm__ __volatile__
        (
            "lock\n\t"
            "xadd %1, %0":
            "+m"( *pw ), "=r"( r ): // outputs (%0, %1)
            "1"( dv ): // inputs (%2 == %1)
            "memory", "cc" // clobbers
        );
        return r;
    }
 };
 } // namespace detail
 } // namespace boost
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_GCC_X86_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/atomic_count_solaris.hpp
+++ b/include/boost/smart_ptr/detail/atomic_count_solaris.hpp
@@ -1,59 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SOLARIS_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SOLARIS_HPP_INCLUDED
 //
 //  boost/detail/atomic_count_solaris.hpp
 //   based on: boost/detail/atomic_count_win32.hpp
 //
 //  Copyright (c) 2001-2005 Peter Dimov
 //  Copyright (c) 2006 Michael van der Westhuizen
 //
 // 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)
 //
 #include <atomic.h>
 namespace boost
 {
 namespace detail
 {
 class atomic_count
 {
 public:
    explicit atomic_count( uint32_t v ): value_( v )
    {
    }
    long operator++()
    {
        return atomic_inc_32_nv( &value_ );
    }
    long operator--()
    {
        return atomic_dec_32_nv( &value_ );
    }
    operator uint32_t() const
    {
        return static_cast<uint32_t const volatile &>( value_ );
    }
 private:
    atomic_count( atomic_count const & );
    atomic_count & operator=( atomic_count const & );
    uint32_t value_;
 };
 } // namespace detail
 } // namespace boost
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SOLARIS_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/atomic_count_sync.hpp
+++ b/include/boost/smart_ptr/detail/atomic_count_sync.hpp
@@ -1,61 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SYNC_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SYNC_HPP_INCLUDED
 //
 //  boost/detail/atomic_count_sync.hpp
 //
 //  atomic_count for g++ 4.1+
 //
 //  http://gcc.gnu.org/onlinedocs/gcc-4.1.1/gcc/Atomic-Builtins.html
 //
 //  Copyright 2007 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)
 //
 #if defined( __ia64__ ) && defined( __INTEL_COMPILER )
 # include <ia64intrin.h>
 #endif
 namespace boost
 {
 namespace detail
 {
 class atomic_count
 {
 public:
    explicit atomic_count( long v ) : value_( v ) {}
    long operator++()
    {
        return __sync_add_and_fetch( &value_, 1 );
    }
    long operator--()
    {
        return __sync_add_and_fetch( &value_, -1 );
    }
    operator long() const
    {
        return __sync_fetch_and_add( &value_, 0 );
    }
 private:
    atomic_count(atomic_count const &);
    atomic_count & operator=(atomic_count const &);
    mutable long value_;
 };
 } // namespace detail
 } // namespace boost
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SYNC_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/atomic_count_win32.hpp
+++ b/include/boost/smart_ptr/detail/atomic_count_win32.hpp
@@ -1,63 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  boost/detail/atomic_count_win32.hpp
 //
 //  Copyright (c) 2001-2005 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)
 //
 #include <boost/detail/interlocked.hpp>
 namespace boost
 {
 namespace detail
 {
 class atomic_count
 {
 public:
    explicit atomic_count( long v ): value_( v )
    {
    }
    long operator++()
    {
        return BOOST_INTERLOCKED_INCREMENT( &value_ );
    }
    long operator--()
    {
        return BOOST_INTERLOCKED_DECREMENT( &value_ );
    }
    operator long() const
    {
        return static_cast<long const volatile &>( value_ );
    }
 private:
    atomic_count( atomic_count const & );
    atomic_count & operator=( atomic_count const & );
    long value_;
 };
 } // namespace detail
 } // namespace boost
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/lightweight_mutex.hpp
+++ b/include/boost/smart_ptr/detail/lightweight_mutex.hpp
@@ -1,42 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  boost/detail/lightweight_mutex.hpp - lightweight mutex
 //
 //  Copyright (c) 2002, 2003 Peter Dimov and Multi Media Ltd.
 //
 // 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)
 //
 //  typedef <unspecified> boost::detail::lightweight_mutex;
 //
 //  boost::detail::lightweight_mutex is a header-only implementation of
 //  a subset of the Mutex concept requirements:
 //
 //  http://www.boost.org/doc/html/threads/concepts.html#threads.concepts.Mutex
 //
 //  It maps to a CRITICAL_SECTION on Windows or a pthread_mutex on POSIX.
 //
 #include <boost/config.hpp>
 #if !defined(BOOST_HAS_THREADS)
 #  include <boost/smart_ptr/detail/lwm_nop.hpp>
 #elif defined(BOOST_HAS_PTHREADS)
 #  include <boost/smart_ptr/detail/lwm_pthreads.hpp>
 #elif defined(BOOST_HAS_WINTHREADS) || defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 #  include <boost/smart_ptr/detail/lwm_win32_cs.hpp>
 #else
 // Use #define BOOST_DISABLE_THREADS to avoid the error
 #  error Unrecognized threading platform
 #endif
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/lwm_nop.hpp
+++ b/include/boost/smart_ptr/detail/lwm_nop.hpp
@@ -1,37 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_LWM_NOP_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_LWM_NOP_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  boost/detail/lwm_nop.hpp
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
 // 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)
 //
 namespace boost
 {
 namespace detail
 {
 class lightweight_mutex
 {
 public:
    typedef lightweight_mutex scoped_lock;
 };
 } // namespace detail
 } // namespace boost
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_LWM_NOP_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/lwm_win32_cs.hpp
+++ b/include/boost/smart_ptr/detail/lwm_win32_cs.hpp
@@ -1,108 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_LWM_WIN32_CS_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_LWM_WIN32_CS_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  boost/detail/lwm_win32_cs.hpp
 //
 //  Copyright (c) 2002, 2003 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)
 //
 #ifdef BOOST_USE_WINDOWS_H
 #  include <windows.h>
 #endif
 namespace boost
 {
 namespace detail
 {
 #ifndef BOOST_USE_WINDOWS_H
 struct critical_section
 {
    struct critical_section_debug * DebugInfo;
    long LockCount;
    long RecursionCount;
    void * OwningThread;
    void * LockSemaphore;
 #if defined(_WIN64)
    unsigned __int64 SpinCount;
 #else
    unsigned long SpinCount;
 #endif
 };
 extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(critical_section *);
 extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(critical_section *);
 extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(critical_section *);
 extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(critical_section *);
 #else
 typedef ::CRITICAL_SECTION critical_section;
 #endif // #ifndef BOOST_USE_WINDOWS_H
 class lightweight_mutex
 {
 private:
    critical_section cs_;
    lightweight_mutex(lightweight_mutex const &);
    lightweight_mutex & operator=(lightweight_mutex const &);
 public:
    lightweight_mutex()
    {
        InitializeCriticalSection(&cs_);
    }
    ~lightweight_mutex()
    {
        DeleteCriticalSection(&cs_);
    }
    class scoped_lock;
    friend class scoped_lock;
    class scoped_lock
    {
    private:
        lightweight_mutex & m_;
        scoped_lock(scoped_lock const &);
        scoped_lock & operator=(scoped_lock const &);
    public:
        explicit scoped_lock(lightweight_mutex & m): m_(m)
        {
            EnterCriticalSection(&m_.cs_);
        }
        ~scoped_lock()
        {
            LeaveCriticalSection(&m_.cs_);
        }
    };
 };
 } // namespace detail
 } // namespace boost
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_LWM_WIN32_CS_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/operator_bool.hpp
+++ b/include/boost/smart_ptr/detail/operator_bool.hpp
@@ -1,56 +0,0 @@
 //  This header intentionally has no include guards.
 //
 //  Copyright (c) 2001-2009 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
 #if ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, < 0x570) ) || defined(__CINT__)
    operator bool () const
    {
        return px != 0;
    }
 #elif defined( _MANAGED )
    static void unspecified_bool( this_type*** )
    {
    }
    typedef void (*unspecified_bool_type)( this_type*** );
    operator unspecified_bool_type() const // never throws
    {
        return px == 0? 0: unspecified_bool;
    }
 #elif \
    ( defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, < 0x3200) ) || \
    ( defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 304) ) || \
    ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590) )
    typedef T * (this_type::*unspecified_bool_type)() const;
    operator unspecified_bool_type() const // never throws
    {
        return px == 0? 0: &this_type::get;
    }
 #else
    typedef T * this_type::*unspecified_bool_type;
    operator unspecified_bool_type() const // never throws
    {
        return px == 0? 0: &this_type::px;
    }
 #endif
    // operator! is redundant, but some compilers need it
    bool operator! () const // never throws
    {
        return px == 0;
    }
--- a/include/boost/smart_ptr/detail/quick_allocator.hpp
+++ b/include/boost/smart_ptr/detail/quick_allocator.hpp
@@ -1,198 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  detail/quick_allocator.hpp
 //
 //  Copyright (c) 2003 David Abrahams
 //  Copyright (c) 2003 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)
 //
 #include <boost/config.hpp>
 #include <boost/smart_ptr/detail/lightweight_mutex.hpp>
 #include <boost/type_traits/type_with_alignment.hpp>
 #include <boost/type_traits/alignment_of.hpp>
 #include <new>              // ::operator new, ::operator delete
 #include <cstddef>          // std::size_t
 namespace boost
 {
 namespace detail
 {
 template<unsigned size, unsigned align_> union freeblock
 {
    typedef typename boost::type_with_alignment<align_>::type aligner_type;
    aligner_type aligner;
    char bytes[size];
    freeblock * next;
 };
 template<unsigned size, unsigned align_> struct allocator_impl
 {
    typedef freeblock<size, align_> block;
    // It may seem odd to use such small pages.
    //
    // However, on a typical Windows implementation that uses
    // the OS allocator, "normal size" pages interact with the
    // "ordinary" operator new, slowing it down dramatically.
    //
    // 512 byte pages are handled by the small object allocator,
    // and don't interfere with ::new.
    //
    // The other alternative is to use much bigger pages (1M.)
    //
    // It is surprisingly easy to hit pathological behavior by
    // varying the page size. g++ 2.96 on Red Hat Linux 7.2,
    // for example, passionately dislikes 496. 512 seems OK.
 #if defined(BOOST_QA_PAGE_SIZE)
    enum { items_per_page = BOOST_QA_PAGE_SIZE / size };
 #else
    enum { items_per_page = 512 / size }; // 1048560 / size
 #endif
 #ifdef BOOST_HAS_THREADS
    static lightweight_mutex & mutex()
    {
        static lightweight_mutex m;
        return m;
    }
    static lightweight_mutex * mutex_init;
 #endif
    static block * free;
    static block * page;
    static unsigned last;
    static inline void * alloc()
    {
 #ifdef BOOST_HAS_THREADS
        lightweight_mutex::scoped_lock lock( mutex() );
 #endif
        if(block * x = free)
        {
            free = x->next;
            return x;
        }
        else
        {
            if(last == items_per_page)
            {
                // "Listen to me carefully: there is no memory leak"
                // -- Scott Meyers, Eff C++ 2nd Ed Item 10
                page = ::new block[items_per_page];
                last = 0;
            }
            return &page[last++];
        }
    }
    static inline void * alloc(std::size_t n)
    {
        if(n != size) // class-specific new called for a derived object
        {
            return ::operator new(n);
        }
        else
        {
 #ifdef BOOST_HAS_THREADS
            lightweight_mutex::scoped_lock lock( mutex() );
 #endif
            if(block * x = free)
            {
                free = x->next;
                return x;
            }
            else
            {
                if(last == items_per_page)
                {
                    page = ::new block[items_per_page];
                    last = 0;
                }
                return &page[last++];
            }
        }
    }
    static inline void dealloc(void * pv)
    {
        if(pv != 0) // 18.4.1.1/13
        {
 #ifdef BOOST_HAS_THREADS
            lightweight_mutex::scoped_lock lock( mutex() );
 #endif
            block * pb = static_cast<block *>(pv);
            pb->next = free;
            free = pb;
        }
    }
    static inline void dealloc(void * pv, std::size_t n)
    {
        if(n != size) // class-specific delete called for a derived object
        {
            ::operator delete(pv);
        }
        else if(pv != 0) // 18.4.1.1/13
        {
 #ifdef BOOST_HAS_THREADS
            lightweight_mutex::scoped_lock lock( mutex() );
 #endif
            block * pb = static_cast<block *>(pv);
            pb->next = free;
            free = pb;
        }
    }
 };
 #ifdef BOOST_HAS_THREADS
 template<unsigned size, unsigned align_>
  lightweight_mutex * allocator_impl<size, align_>::mutex_init = &allocator_impl<size, align_>::mutex();
 #endif
 template<unsigned size, unsigned align_>
  freeblock<size, align_> * allocator_impl<size, align_>::free = 0;
 template<unsigned size, unsigned align_>
  freeblock<size, align_> * allocator_impl<size, align_>::page = 0;
 template<unsigned size, unsigned align_>
  unsigned allocator_impl<size, align_>::last = allocator_impl<size, align_>::items_per_page;
 template<class T>
 struct quick_allocator: public allocator_impl< sizeof(T), boost::alignment_of<T>::value >
 {
 };
 } // namespace detail
 } // namespace boost
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/shared_count.hpp
+++ b/include/boost/smart_ptr/detail/shared_count.hpp
@@ -1,444 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SHARED_COUNT_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SHARED_COUNT_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  detail/shared_count.hpp
 //
 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
 //  Copyright 2004-2005 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)
 //
 #ifdef __BORLANDC__
 # pragma warn -8027     // Functions containing try are not expanded inline
 #endif
 #include <boost/config.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/throw_exception.hpp>
 #include <boost/smart_ptr/bad_weak_ptr.hpp>
 #include <boost/smart_ptr/detail/sp_counted_base.hpp>
 #include <boost/smart_ptr/detail/sp_counted_impl.hpp>
 #include <boost/detail/workaround.hpp>
 // In order to avoid circular dependencies with Boost.TR1
 // we make sure that our include of <memory> doesn't try to
 // pull in the TR1 headers: that's why we use this header 
 // rather than including <memory> directly:
 #include <boost/config/no_tr1/memory.hpp>  // std::auto_ptr
 #include <functional>       // std::less
 #include <new>              // std::bad_alloc
 namespace boost
 {
 namespace detail
 {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
 int const shared_count_id = 0x2C35F101;
 int const   weak_count_id = 0x298C38A4;
 #endif
 struct sp_nothrow_tag {};
 class weak_count;
 class shared_count
 {
 private:
    sp_counted_base * pi_;
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
    int id_;
 #endif
    friend class weak_count;
 public:
    shared_count(): pi_(0) // nothrow
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        , id_(shared_count_id)
 #endif
    {
    }
    template<class Y> explicit shared_count( Y * p ): pi_( 0 )
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        , id_(shared_count_id)
 #endif
    {
 #ifndef BOOST_NO_EXCEPTIONS
        try
        {
            pi_ = new sp_counted_impl_p<Y>( p );
        }
        catch(...)
        {
            boost::checked_delete( p );
            throw;
        }
 #else
        pi_ = new sp_counted_impl_p<Y>( p );
        if( pi_ == 0 )
        {
            boost::checked_delete( p );
            boost::throw_exception( std::bad_alloc() );
        }
 #endif
    }
 #if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1200 )
    template<class Y, class D> shared_count( Y * p, D d ): pi_(0)
 #else
    template<class P, class D> shared_count( P p, D d ): pi_(0)
 #endif
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        , id_(shared_count_id)
 #endif
    {
 #if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1200 )
        typedef Y* P;
 #endif
 #ifndef BOOST_NO_EXCEPTIONS
        try
        {
            pi_ = new sp_counted_impl_pd<P, D>(p, d);
        }
        catch(...)
        {
            d(p); // delete p
            throw;
        }
 #else
        pi_ = new sp_counted_impl_pd<P, D>(p, d);
        if(pi_ == 0)
        {
            d(p); // delete p
            boost::throw_exception(std::bad_alloc());
        }
 #endif
    }
    template<class P, class D, class A> shared_count( P p, D d, A a ): pi_( 0 )
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        , id_(shared_count_id)
 #endif
    {
        typedef sp_counted_impl_pda<P, D, A> impl_type;
        typedef typename A::template rebind< impl_type >::other A2;
        A2 a2( a );
 #ifndef BOOST_NO_EXCEPTIONS
        try
        {
            pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
            new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
        }
        catch(...)
        {
            d( p );
            if( pi_ != 0 )
            {
                a2.deallocate( static_cast< impl_type* >( pi_ ), 1 );
            }
            throw;
        }
 #else
        pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
        if( pi_ != 0 )
        {
            new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
        }
        else
        {
            d( p );
            boost::throw_exception( std::bad_alloc() );
        }
 #endif
    }
 #ifndef BOOST_NO_AUTO_PTR
    // auto_ptr<Y> is special cased to provide the strong guarantee
    template<class Y>
    explicit shared_count( std::auto_ptr<Y> & r ): pi_( new sp_counted_impl_p<Y>( r.get() ) )
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        , id_(shared_count_id)
 #endif
    {
 #ifdef BOOST_NO_EXCEPTIONS
        if( pi_ == 0 )
        {
            boost::throw_exception(std::bad_alloc());
        }
 #endif
        r.release();
    }
 #endif 
    ~shared_count() // nothrow
    {
        if( pi_ != 0 ) pi_->release();
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        id_ = 0;
 #endif
    }
    shared_count(shared_count const & r): pi_(r.pi_) // nothrow
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        , id_(shared_count_id)
 #endif
    {
        if( pi_ != 0 ) pi_->add_ref_copy();
    }
 #if defined( BOOST_HAS_RVALUE_REFS )
    shared_count(shared_count && r): pi_(r.pi_) // nothrow
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        , id_(shared_count_id)
 #endif
    {
        r.pi_ = 0;
    }
 #endif
    explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0
    shared_count( weak_count const & r, sp_nothrow_tag ); // constructs an empty *this when r.use_count() == 0
    shared_count & operator= (shared_count const & r) // nothrow
    {
        sp_counted_base * tmp = r.pi_;
        if( tmp != pi_ )
        {
            if( tmp != 0 ) tmp->add_ref_copy();
            if( pi_ != 0 ) pi_->release();
            pi_ = tmp;
        }
        return *this;
    }
    void swap(shared_count & r) // nothrow
    {
        sp_counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }
    long use_count() const // nothrow
    {
        return pi_ != 0? pi_->use_count(): 0;
    }
    bool unique() const // nothrow
    {
        return use_count() == 1;
    }
    bool empty() const // nothrow
    {
        return pi_ == 0;
    }
    friend inline bool operator==(shared_count const & a, shared_count const & b)
    {
        return a.pi_ == b.pi_;
    }
    friend inline bool operator<(shared_count const & a, shared_count const & b)
    {
        return std::less<sp_counted_base *>()( a.pi_, b.pi_ );
    }
    void * get_deleter( sp_typeinfo const & ti ) const
    {
        return pi_? pi_->get_deleter( ti ): 0;
    }
 };
 class weak_count
 {
 private:
    sp_counted_base * pi_;
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
    int id_;
 #endif
    friend class shared_count;
 public:
    weak_count(): pi_(0) // nothrow
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        , id_(weak_count_id)
 #endif
    {
    }
    weak_count(shared_count const & r): pi_(r.pi_) // nothrow
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        , id_(weak_count_id)
 #endif
    {
        if(pi_ != 0) pi_->weak_add_ref();
    }
    weak_count(weak_count const & r): pi_(r.pi_) // nothrow
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        , id_(weak_count_id)
 #endif
    {
        if(pi_ != 0) pi_->weak_add_ref();
    }
 // Move support
 #if defined( BOOST_HAS_RVALUE_REFS )
    weak_count(weak_count && r): pi_(r.pi_) // nothrow
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        , id_(weak_count_id)
 #endif
    {
        r.pi_ = 0;
    }
 #endif
    ~weak_count() // nothrow
    {
        if(pi_ != 0) pi_->weak_release();
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        id_ = 0;
 #endif
    }
    weak_count & operator= (shared_count const & r) // nothrow
    {
        sp_counted_base * tmp = r.pi_;
        if( tmp != pi_ )
        {
            if(tmp != 0) tmp->weak_add_ref();
            if(pi_ != 0) pi_->weak_release();
            pi_ = tmp;
        }
        return *this;
    }
    weak_count & operator= (weak_count const & r) // nothrow
    {
        sp_counted_base * tmp = r.pi_;
        if( tmp != pi_ )
        {
            if(tmp != 0) tmp->weak_add_ref();
            if(pi_ != 0) pi_->weak_release();
            pi_ = tmp;
        }
        return *this;
    }
    void swap(weak_count & r) // nothrow
    {
        sp_counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }
    long use_count() const // nothrow
    {
        return pi_ != 0? pi_->use_count(): 0;
    }
    bool empty() const // nothrow
    {
        return pi_ == 0;
    }
    friend inline bool operator==(weak_count const & a, weak_count const & b)
    {
        return a.pi_ == b.pi_;
    }
    friend inline bool operator<(weak_count const & a, weak_count const & b)
    {
        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
    }
 };
 inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        , id_(shared_count_id)
 #endif
 {
    if( pi_ == 0 || !pi_->add_ref_lock() )
    {
        boost::throw_exception( boost::bad_weak_ptr() );
    }
 }
 inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ): pi_( r.pi_ )
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        , id_(shared_count_id)
 #endif
 {
    if( pi_ != 0 && !pi_->add_ref_lock() )
    {
        pi_ = 0;
    }
 }
 } // namespace detail
 } // namespace boost
 #ifdef __BORLANDC__
 # pragma warn .8027     // Functions containing try are not expanded inline
 #endif
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SHARED_COUNT_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_convertible.hpp
+++ b/include/boost/smart_ptr/detail/sp_convertible.hpp
@@ -1,76 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SP_CONVERTIBLE_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SP_CONVERTIBLE_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //  detail/sp_convertible.hpp
 //
 //  Copyright 2008 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
 #include <boost/config.hpp>
 #if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && defined( BOOST_NO_SFINAE )
 # define BOOST_SP_NO_SP_CONVERTIBLE
 #endif
 #if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && defined( __GNUC__ ) && ( __GNUC__ * 100 + __GNUC_MINOR__ < 303 )
 # define BOOST_SP_NO_SP_CONVERTIBLE
 #endif
 #if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && defined( __BORLANDC__ ) && ( __BORLANDC__ <= 0x610 )
 # define BOOST_SP_NO_SP_CONVERTIBLE
 #endif
 #if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
 namespace boost
 {
 namespace detail
 {
 template< class Y, class T > struct sp_convertible
 {
    typedef char (&yes) [1];
    typedef char (&no)  [2];
    static yes f( T* );
    static no  f( ... );
    enum _vt { value = sizeof( f( static_cast<Y*>(0) ) ) == sizeof(yes) };
 };
 struct sp_empty
 {
 };
 template< bool > struct sp_enable_if_convertible_impl;
 template<> struct sp_enable_if_convertible_impl<true>
 {
    typedef sp_empty type;
 };
 template<> struct sp_enable_if_convertible_impl<false>
 {
 };
 template< class Y, class T > struct sp_enable_if_convertible: public sp_enable_if_convertible_impl< sp_convertible< Y, T >::value >
 {
 };
 } // namespace detail
 } // namespace boost
 #endif // !defined( BOOST_SP_NO_SP_CONVERTIBLE )
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_CONVERTIBLE_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_counted_base.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_base.hpp
@@ -1,70 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  detail/sp_counted_base.hpp
 //
 //  Copyright 2005, 2006 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)
 //
 #include <boost/config.hpp>
 #include <boost/smart_ptr/detail/sp_has_sync.hpp>
 #if defined( BOOST_SP_DISABLE_THREADS )
 # include <boost/smart_ptr/detail/sp_counted_base_nt.hpp>
 #elif defined( BOOST_SP_USE_SPINLOCK )
 # include <boost/smart_ptr/detail/sp_counted_base_spin.hpp>
 #elif defined( BOOST_SP_USE_PTHREADS )
 # include <boost/smart_ptr/detail/sp_counted_base_pt.hpp>
 #elif defined( BOOST_DISABLE_THREADS ) && !defined( BOOST_SP_ENABLE_THREADS ) && !defined( BOOST_DISABLE_WIN32 )
 # include <boost/smart_ptr/detail/sp_counted_base_nt.hpp>
 #elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) )
 # include <boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp>
 #elif defined( __GNUC__ ) && defined( __ia64__ ) && !defined( __INTEL_COMPILER )
 # include <boost/smart_ptr/detail/sp_counted_base_gcc_ia64.hpp>
 #elif defined(__HP_aCC) && defined(__ia64)
 # include <boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp>
 #elif defined( __MWERKS__ ) && defined( __POWERPC__ )
 # include <boost/smart_ptr/detail/sp_counted_base_cw_ppc.hpp>
 #elif defined( __GNUC__ ) && ( defined( __powerpc__ ) || defined( __ppc__ ) || defined( __ppc ) )
 # include <boost/smart_ptr/detail/sp_counted_base_gcc_ppc.hpp>
 #elif defined( __GNUC__ ) && ( defined( __mips__ ) || defined( _mips ) )
 # include <boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp>
 #elif defined( BOOST_SP_HAS_SYNC )
 # include <boost/smart_ptr/detail/sp_counted_base_sync.hpp>
 #elif defined(__GNUC__) && ( defined( __sparcv9 ) || ( defined( __sparcv8 ) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 402 ) ) )
 # include <boost/smart_ptr/detail/sp_counted_base_gcc_sparc.hpp>
 #elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) || defined(__CYGWIN__)
 # include <boost/smart_ptr/detail/sp_counted_base_w32.hpp>
 #elif !defined( BOOST_HAS_THREADS )
 # include <boost/smart_ptr/detail/sp_counted_base_nt.hpp>
 #else
 # include <boost/smart_ptr/detail/sp_counted_base_spin.hpp>
 #endif
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp
@@ -1,150 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_ACC_IA64_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_ACC_IA64_HPP_INCLUDED
 //
 //  detail/sp_counted_base_acc_ia64.hpp - aC++ on HP-UX IA64
 //
 //  Copyright 2007 Baruch Zilber
 //  Copyright 2007 Boris Gubenko
 //
 //  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)
 //
 //
 //  Lock-free algorithm by Alexander Terekhov
 //
 #include <boost/detail/sp_typeinfo.hpp>
 #include <machine/sys/inline.h>
 namespace boost
 {
 namespace detail
 {
 inline void atomic_increment( int * pw )
 {
    // ++*pw;
    _Asm_fetchadd(_FASZ_W, _SEM_REL, pw, +1, _LDHINT_NONE);
 } 
 inline int atomic_decrement( int * pw )
 {
    // return --*pw;
    int r = static_cast<int>(_Asm_fetchadd(_FASZ_W, _SEM_REL, pw, -1, _LDHINT_NONE));
    if (1 == r)
    {
        _Asm_mf();
    }
    return r - 1;
 }
 inline int atomic_conditional_increment( int * pw )
 {
    // if( *pw != 0 ) ++*pw;
    // return *pw;
    int v = *pw;
    for (;;)
    {
        if (0 == v)
        {
            return 0;
        }
        _Asm_mov_to_ar(_AREG_CCV,
                       v,
                       (_UP_CALL_FENCE | _UP_SYS_FENCE | _DOWN_CALL_FENCE | _DOWN_SYS_FENCE));
        int r = static_cast<int>(_Asm_cmpxchg(_SZ_W, _SEM_ACQ, pw, v + 1, _LDHINT_NONE));
        if (r == v)
        {
            return r + 1;
        }
        v = r;
    }
 }
 class sp_counted_base
 {
 private:
    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );
    int use_count_;        // #shared
    int weak_count_;       // #weak + (#shared != 0)
 public:
    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
    {
    }
    virtual ~sp_counted_base() // nothrow
    {
    }
    // dispose() is called when use_count_ drops to zero, to release
    // the resources managed by *this.
    virtual void dispose() = 0; // nothrow
    // destroy() is called when weak_count_ drops to zero.
    virtual void destroy() // nothrow
    {
        delete this;
    }
    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
    void add_ref_copy()
    {
        atomic_increment( &use_count_ );
    }
    bool add_ref_lock() // true on success
    {
        return atomic_conditional_increment( &use_count_ ) != 0;
    }
    void release() // nothrow
    {
        if( atomic_decrement( &use_count_ ) == 0 )
        {
            dispose();
            weak_release();
        }
    }
    void weak_add_ref() // nothrow
    {
        atomic_increment( &weak_count_ );
    }
    void weak_release() // nothrow
    {
        if( atomic_decrement( &weak_count_ ) == 0 )
        {
            destroy();
        }
    }
    long use_count() const // nothrow
    {
        return static_cast<int const volatile &>( use_count_ ); // TODO use ld.acq here
    }
 };
 } // namespace detail
 } // namespace boost
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_ACC_IA64_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_counted_base_cw_ppc.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_base_cw_ppc.hpp
@@ -1,170 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CW_PPC_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CW_PPC_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  detail/sp_counted_base_cw_ppc.hpp - CodeWarrior on PowerPC
 //
 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
 //  Copyright 2004-2005 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)
 //
 //
 //  Lock-free algorithm by Alexander Terekhov
 //
 //  Thanks to Ben Hitchings for the #weak + (#shared != 0)
 //  formulation
 //
 #include <boost/detail/sp_typeinfo.hpp>
 namespace boost
 {
 namespace detail
 {
 inline void atomic_increment( register long * pw )
 {
    register int a;
    asm
    {
 loop:
    lwarx   a, 0, pw
    addi    a, a, 1
    stwcx.  a, 0, pw
    bne-    loop
    }
 }
 inline long atomic_decrement( register long * pw )
 {
    register int a;
    asm
    {
    sync
 loop:
    lwarx   a, 0, pw
    addi    a, a, -1
    stwcx.  a, 0, pw
    bne-    loop
    isync
    }
    return a;
 }
 inline long atomic_conditional_increment( register long * pw )
 {
    register int a;
    asm
    {
 loop:
    lwarx   a, 0, pw
    cmpwi   a, 0
    beq     store
    addi    a, a, 1
 store:
    stwcx.  a, 0, pw
    bne-    loop
    }
    return a;
 }
 class sp_counted_base
 {
 private:
    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );
    long use_count_;        // #shared
    long weak_count_;       // #weak + (#shared != 0)
 public:
    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
    {
    }
    virtual ~sp_counted_base() // nothrow
    {
    }
    // dispose() is called when use_count_ drops to zero, to release
    // the resources managed by *this.
    virtual void dispose() = 0; // nothrow
    // destroy() is called when weak_count_ drops to zero.
    virtual void destroy() // nothrow
    {
        delete this;
    }
    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
    void add_ref_copy()
    {
        atomic_increment( &use_count_ );
    }
    bool add_ref_lock() // true on success
    {
        return atomic_conditional_increment( &use_count_ ) != 0;
    }
    void release() // nothrow
    {
        if( atomic_decrement( &use_count_ ) == 0 )
        {
            dispose();
            weak_release();
        }
    }
    void weak_add_ref() // nothrow
    {
        atomic_increment( &weak_count_ );
    }
    void weak_release() // nothrow
    {
        if( atomic_decrement( &weak_count_ ) == 0 )
        {
            destroy();
        }
    }
    long use_count() const // nothrow
    {
        return static_cast<long const volatile &>( use_count_ );
    }
 };
 } // namespace detail
 } // namespace boost
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CW_PPC_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_counted_base_cw_x86.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_base_cw_x86.hpp
@@ -1,158 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CW_X86_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CW_X86_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  detail/sp_counted_base_cw_x86.hpp - CodeWarrion on 486+
 //
 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
 //  Copyright 2004-2005 Peter Dimov
 //  Copyright 2005 Rene Rivera
 //
 //  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)
 //
 //
 //  Lock-free algorithm by Alexander Terekhov
 //
 //  Thanks to Ben Hitchings for the #weak + (#shared != 0)
 //  formulation
 //
 #include <boost/detail/sp_typeinfo.hpp>
 namespace boost
 {
 namespace detail
 {
 inline int atomic_exchange_and_add( int * pw, int dv )
 {
    // int r = *pw;
    // *pw += dv;
    // return r;
    asm
    {
        mov esi, [pw]
        mov eax, dv
        lock xadd dword ptr [esi], eax
    }
 }
 inline void atomic_increment( int * pw )
 {
    //atomic_exchange_and_add( pw, 1 );
    asm
    {
        mov esi, [pw]
        lock inc dword ptr [esi]
    }
 }
 inline int atomic_conditional_increment( int * pw )
 {
    // int rv = *pw;
    // if( rv != 0 ) ++*pw;
    // return rv;
    asm
    {
        mov esi, [pw]
        mov eax, dword ptr [esi]
    L0:
        test eax, eax
        je L1
        mov ebx, eax
        inc ebx
        lock cmpxchg dword ptr [esi], ebx
        jne L0
    L1:
    }
 }
 class sp_counted_base
 {
 private:
    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );
    int use_count_;        // #shared
    int weak_count_;       // #weak + (#shared != 0)
 public:
    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
    {
    }
    virtual ~sp_counted_base() // nothrow
    {
    }
    // dispose() is called when use_count_ drops to zero, to release
    // the resources managed by *this.
    virtual void dispose() = 0; // nothrow
    // destroy() is called when weak_count_ drops to zero.
    virtual void destroy() // nothrow
    {
        delete this;
    }
    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
    void add_ref_copy()
    {
        atomic_increment( &use_count_ );
    }
    bool add_ref_lock() // true on success
    {
        return atomic_conditional_increment( &use_count_ ) != 0;
    }
    void release() // nothrow
    {
        if( atomic_exchange_and_add( &use_count_, -1 ) == 1 )
        {
            dispose();
            weak_release();
        }
    }
    void weak_add_ref() // nothrow
    {
        atomic_increment( &weak_count_ );
    }
    void weak_release() // nothrow
    {
        if( atomic_exchange_and_add( &weak_count_, -1 ) == 1 )
        {
            destroy();
        }
    }
    long use_count() const // nothrow
    {
        return static_cast<int const volatile &>( use_count_ );
    }
 };
 } // namespace detail
 } // namespace boost
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CW_X86_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_counted_base_gcc_ia64.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_base_gcc_ia64.hpp
@@ -1,157 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_GCC_IA64_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_GCC_IA64_HPP_INCLUDED
 //
 //  detail/sp_counted_base_gcc_ia64.hpp - g++ on IA64
 //
 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
 //  Copyright 2004-2006 Peter Dimov
 //  Copyright 2005 Ben Hutchings
 //
 //  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)
 //
 //
 //  Lock-free algorithm by Alexander Terekhov
 //
 #include <boost/detail/sp_typeinfo.hpp>
 namespace boost
 {
 namespace detail
 {
 inline void atomic_increment( int * pw )
 {
    // ++*pw;
    int tmp;
    // No barrier is required here but fetchadd always has an acquire or
    // release barrier associated with it.  We choose release as it should be
    // cheaper.
    __asm__ ("fetchadd4.rel %0=%1,1" :
         "=r"(tmp), "=m"(*pw) :
         "m"( *pw ));
 }
 inline int atomic_decrement( int * pw )
 {
    // return --*pw;
    int rv;
    __asm__ ("     fetchadd4.rel %0=%1,-1 ;; \n"
             "     cmp.eq        p7,p0=1,%0 ;; \n"
             "(p7) ld4.acq       %0=%1    " :
             "=&r"(rv), "=m"(*pw) :
             "m"( *pw ) :
             "p7");
    return rv;
 }
 inline int atomic_conditional_increment( int * pw )
 {
    // if( *pw != 0 ) ++*pw;
    // return *pw;
    int rv, tmp, tmp2;
    __asm__ ("0:   ld4          %0=%3           ;; \n"
         "     cmp.eq       p7,p0=0,%0        ;; \n"
         "(p7) br.cond.spnt 1f                \n"
         "     mov          ar.ccv=%0         \n"
         "     add          %1=1,%0           ;; \n"
         "     cmpxchg4.acq %2=%3,%1,ar.ccv ;; \n"
         "     cmp.ne       p7,p0=%0,%2       ;; \n"
         "(p7) br.cond.spnt 0b                \n"
         "     mov          %0=%1             ;; \n"
         "1:" : 
         "=&r"(rv), "=&r"(tmp), "=&r"(tmp2), "=m"(*pw) :
         "m"( *pw ) :
         "ar.ccv", "p7");
    return rv;
 }
 class sp_counted_base
 {
 private:
    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );
    int use_count_;        // #shared
    int weak_count_;       // #weak + (#shared != 0)
 public:
    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
    {
    }
    virtual ~sp_counted_base() // nothrow
    {
    }
    // dispose() is called when use_count_ drops to zero, to release
    // the resources managed by *this.
    virtual void dispose() = 0; // nothrow
    // destroy() is called when weak_count_ drops to zero.
    virtual void destroy() // nothrow
    {
        delete this;
    }
    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
    void add_ref_copy()
    {
        atomic_increment( &use_count_ );
    }
    bool add_ref_lock() // true on success
    {
        return atomic_conditional_increment( &use_count_ ) != 0;
    }
    void release() // nothrow
    {
        if( atomic_decrement( &use_count_ ) == 0 )
        {
            dispose();
            weak_release();
        }
    }
    void weak_add_ref() // nothrow
    {
        atomic_increment( &weak_count_ );
    }
    void weak_release() // nothrow
    {
        if( atomic_decrement( &weak_count_ ) == 0 )
        {
            destroy();
        }
    }
    long use_count() const // nothrow
    {
        return static_cast<int const volatile &>( use_count_ ); // TODO use ld.acq here
    }
 };
 } // namespace detail
 } // namespace boost
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_GCC_IA64_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp
@@ -1,172 +0,0 @@
 #ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_MIPS_HPP_INCLUDED
 #define BOOST_DETAIL_SP_COUNTED_BASE_GCC_MIPS_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  detail/sp_counted_base_gcc_mips.hpp - g++ on MIPS
 //
 //  Copyright (c) 2009, Spirent Communications, Inc.
 //
 //  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)
 //
 //
 //  Lock-free algorithm by Alexander Terekhov
 //
 #include <boost/detail/sp_typeinfo.hpp>
 namespace boost
 {
 namespace detail
 {
 inline void atomic_increment( int * pw )
 {
    // ++*pw;
    int tmp;
    __asm__ __volatile__
    (
        "0:\n\t"
        "ll %0, %1\n\t"
        "addiu %0, 1\n\t"
        "sc %0, %1\n\t"
        "beqz %0, 0b":
        "=&r"( tmp ), "=m"( *pw ):
        "m"( *pw )
    );
 }
 inline int atomic_decrement( int * pw )
 {
    // return --*pw;
    int rv, tmp;
    __asm__ __volatile__
    (
        "0:\n\t"
        "ll %1, %2\n\t"
        "addiu %0, %1, -1\n\t"
        "sc %0, %2\n\t"
        "beqz %0, 0b\n\t"
        "addiu %0, %1, -1":
        "=&r"( rv ), "=&r"( tmp ), "=m"( *pw ):
        "m"( *pw ):
        "memory"
    );
    return rv;
 }
 inline int atomic_conditional_increment( int * pw )
 {
    // if( *pw != 0 ) ++*pw;
    // return *pw;
    int rv, tmp;
    __asm__ __volatile__
    (
        "0:\n\t"
        "ll %0, %2\n\t"
        "beqz %0, 1f\n\t"
        "addiu %1, %0, 1\n\t"
        "sc %1, %2\n\t"
        "beqz %1, 0b\n\t"
        "addiu %0, %0, 1\n\t"
        "1:":
        "=&r"( rv ), "=&r"( tmp ), "=m"( *pw ):
        "m"( *pw ):
        "memory"
    );
    return rv;
 }
 class sp_counted_base
 {
 private:
    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );
    int use_count_;        // #shared
    int weak_count_;       // #weak + (#shared != 0)
 public:
    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
    {
    }
    virtual ~sp_counted_base() // nothrow
    {
    }
    // dispose() is called when use_count_ drops to zero, to release
    // the resources managed by *this.
    virtual void dispose() = 0; // nothrow
    // destroy() is called when weak_count_ drops to zero.
    virtual void destroy() // nothrow
    {
        delete this;
    }
    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
    void add_ref_copy()
    {
        atomic_increment( &use_count_ );
    }
    bool add_ref_lock() // true on success
    {
        return atomic_conditional_increment( &use_count_ ) != 0;
    }
    void release() // nothrow
    {
        if( atomic_decrement( &use_count_ ) == 0 )
        {
            dispose();
            weak_release();
        }
    }
    void weak_add_ref() // nothrow
    {
        atomic_increment( &weak_count_ );
    }
    void weak_release() // nothrow
    {
        if( atomic_decrement( &weak_count_ ) == 0 )
        {
            destroy();
        }
    }
    long use_count() const // nothrow
    {
        return static_cast<int const volatile &>( use_count_ );
    }
 };
 } // namespace detail
 } // namespace boost
 #endif  // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_MIPS_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_counted_base_gcc_ppc.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_base_gcc_ppc.hpp
@@ -1,181 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_GCC_PPC_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_GCC_PPC_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  detail/sp_counted_base_gcc_ppc.hpp - g++ on PowerPC
 //
 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
 //  Copyright 2004-2005 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)
 //
 //
 //  Lock-free algorithm by Alexander Terekhov
 //
 //  Thanks to Ben Hitchings for the #weak + (#shared != 0)
 //  formulation
 //
 #include <boost/detail/sp_typeinfo.hpp>
 namespace boost
 {
 namespace detail
 {
 inline void atomic_increment( int * pw )
 {
    // ++*pw;
    int tmp;
    __asm__
    (
        "0:\n\t"
        "lwarx %1, 0, %2\n\t"
        "addi %1, %1, 1\n\t"
        "stwcx. %1, 0, %2\n\t"
        "bne- 0b":
        "=m"( *pw ), "=&b"( tmp ):
        "r"( pw ), "m"( *pw ):
        "cc"
    );
 }
 inline int atomic_decrement( int * pw )
 {
    // return --*pw;
    int rv;
    __asm__ __volatile__
    (
        "sync\n\t"
        "0:\n\t"
        "lwarx %1, 0, %2\n\t"
        "addi %1, %1, -1\n\t"
        "stwcx. %1, 0, %2\n\t"
        "bne- 0b\n\t"
        "isync":
        "=m"( *pw ), "=&b"( rv ):
        "r"( pw ), "m"( *pw ):
        "memory", "cc"
    );
    return rv;
 }
 inline int atomic_conditional_increment( int * pw )
 {
    // if( *pw != 0 ) ++*pw;
    // return *pw;
    int rv;
    __asm__
    (
        "0:\n\t"
        "lwarx %1, 0, %2\n\t"
        "cmpwi %1, 0\n\t"
        "beq 1f\n\t"
        "addi %1, %1, 1\n\t"
        "1:\n\t"
        "stwcx. %1, 0, %2\n\t"
        "bne- 0b":
        "=m"( *pw ), "=&b"( rv ):
        "r"( pw ), "m"( *pw ):
        "cc"
    );
    return rv;
 }
 class sp_counted_base
 {
 private:
    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );
    int use_count_;        // #shared
    int weak_count_;       // #weak + (#shared != 0)
 public:
    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
    {
    }
    virtual ~sp_counted_base() // nothrow
    {
    }
    // dispose() is called when use_count_ drops to zero, to release
    // the resources managed by *this.
    virtual void dispose() = 0; // nothrow
    // destroy() is called when weak_count_ drops to zero.
    virtual void destroy() // nothrow
    {
        delete this;
    }
    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
    void add_ref_copy()
    {
        atomic_increment( &use_count_ );
    }
    bool add_ref_lock() // true on success
    {
        return atomic_conditional_increment( &use_count_ ) != 0;
    }
    void release() // nothrow
    {
        if( atomic_decrement( &use_count_ ) == 0 )
        {
            dispose();
            weak_release();
        }
    }
    void weak_add_ref() // nothrow
    {
        atomic_increment( &weak_count_ );
    }
    void weak_release() // nothrow
    {
        if( atomic_decrement( &weak_count_ ) == 0 )
        {
            destroy();
        }
    }
    long use_count() const // nothrow
    {
        return static_cast<int const volatile &>( use_count_ );
    }
 };
 } // namespace detail
 } // namespace boost
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_GCC_PPC_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_counted_base_gcc_sparc.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_base_gcc_sparc.hpp
@@ -1,166 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_GCC_SPARC_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_GCC_SPARC_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //  detail/sp_counted_base_gcc_sparc.hpp - g++ on Sparc V8+
 //
 //  Copyright (c) 2006 Piotr Wyderski
 //  Copyright (c) 2006 Tomas Puverle
 //  Copyright (c) 2006 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
 //
 //  Thanks to Michael van der Westhuizen
 #include <boost/detail/sp_typeinfo.hpp>
 #include <inttypes.h> // int32_t
 namespace boost
 {
 namespace detail
 {
 inline int32_t compare_and_swap( int32_t * dest_, int32_t compare_, int32_t swap_ )
 {
    __asm__ __volatile__( "cas %0, %2, %1"
                        : "+m" (*dest_), "+r" (swap_)
                        : "r" (compare_)
                        : "memory" );
    return swap_;
 }
 inline int32_t atomic_fetch_and_add( int32_t * pw, int32_t dv )
 {
    // long r = *pw;
    // *pw += dv;
    // return r;
    for( ;; )
    {
        int32_t r = *pw;
        if( __builtin_expect((compare_and_swap(pw, r, r + dv) == r), 1) )
        {
            return r;
        }
    }
 }
 inline void atomic_increment( int32_t * pw )
 {
    atomic_fetch_and_add( pw, 1 );
 }
 inline int32_t atomic_decrement( int32_t * pw )
 {
    return atomic_fetch_and_add( pw, -1 );
 }
 inline int32_t atomic_conditional_increment( int32_t * pw )
 {
    // long r = *pw;
    // if( r != 0 ) ++*pw;
    // return r;
    for( ;; )
    {
        int32_t r = *pw;
        if( r == 0 )
        {
            return r;
        }
        if( __builtin_expect( ( compare_and_swap( pw, r, r + 1 ) == r ), 1 ) )
        {
            return r;
        }
    }    
 }
 class sp_counted_base
 {
 private:
    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );
    int32_t use_count_;        // #shared
    int32_t weak_count_;       // #weak + (#shared != 0)
 public:
    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
    {
    }
    virtual ~sp_counted_base() // nothrow
    {
    }
    // dispose() is called when use_count_ drops to zero, to release
    // the resources managed by *this.
    virtual void dispose() = 0; // nothrow
    // destroy() is called when weak_count_ drops to zero.
    virtual void destroy() // nothrow
    {
        delete this;
    }
    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
    void add_ref_copy()
    {
        atomic_increment( &use_count_ );
    }
    bool add_ref_lock() // true on success
    {
        return atomic_conditional_increment( &use_count_ ) != 0;
    }
    void release() // nothrow
    {
        if( atomic_decrement( &use_count_ ) == 1 )
        {
            dispose();
            weak_release();
        }
    }
    void weak_add_ref() // nothrow
    {
        atomic_increment( &weak_count_ );
    }
    void weak_release() // nothrow
    {
        if( atomic_decrement( &weak_count_ ) == 1 )
        {
            destroy();
        }
    }
    long use_count() const // nothrow
    {
        return const_cast< int32_t const volatile & >( use_count_ );
    }
 };
 } // namespace detail
 } // namespace boost
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_GCC_SPARC_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp
@@ -1,173 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_GCC_X86_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_GCC_X86_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  detail/sp_counted_base_gcc_x86.hpp - g++ on 486+ or AMD64
 //
 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
 //  Copyright 2004-2005 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)
 //
 //
 //  Lock-free algorithm by Alexander Terekhov
 //
 //  Thanks to Ben Hitchings for the #weak + (#shared != 0)
 //  formulation
 //
 #include <boost/detail/sp_typeinfo.hpp>
 namespace boost
 {
 namespace detail
 {
 inline int atomic_exchange_and_add( int * pw, int dv )
 {
    // int r = *pw;
    // *pw += dv;
    // return r;
    int r;
    __asm__ __volatile__
    (
        "lock\n\t"
        "xadd %1, %0":
        "=m"( *pw ), "=r"( r ): // outputs (%0, %1)
        "m"( *pw ), "1"( dv ): // inputs (%2, %3 == %1)
        "memory", "cc" // clobbers
    );
    return r;
 }
 inline void atomic_increment( int * pw )
 {
    //atomic_exchange_and_add( pw, 1 );
    __asm__
    (
        "lock\n\t"
        "incl %0":
        "=m"( *pw ): // output (%0)
        "m"( *pw ): // input (%1)
        "cc" // clobbers
    );
 }
 inline int atomic_conditional_increment( int * pw )
 {
    // int rv = *pw;
    // if( rv != 0 ) ++*pw;
    // return rv;
    int rv, tmp;
    __asm__
    (
        "movl %0, %%eax\n\t"
        "0:\n\t"
        "test %%eax, %%eax\n\t"
        "je 1f\n\t"
        "movl %%eax, %2\n\t"
        "incl %2\n\t"
        "lock\n\t"
        "cmpxchgl %2, %0\n\t"
        "jne 0b\n\t"
        "1:":
        "=m"( *pw ), "=&a"( rv ), "=&r"( tmp ): // outputs (%0, %1, %2)
        "m"( *pw ): // input (%3)
        "cc" // clobbers
    );
    return rv;
 }
 class sp_counted_base
 {
 private:
    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );
    int use_count_;        // #shared
    int weak_count_;       // #weak + (#shared != 0)
 public:
    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
    {
    }
    virtual ~sp_counted_base() // nothrow
    {
    }
    // dispose() is called when use_count_ drops to zero, to release
    // the resources managed by *this.
    virtual void dispose() = 0; // nothrow
    // destroy() is called when weak_count_ drops to zero.
    virtual void destroy() // nothrow
    {
        delete this;
    }
    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
    void add_ref_copy()
    {
        atomic_increment( &use_count_ );
    }
    bool add_ref_lock() // true on success
    {
        return atomic_conditional_increment( &use_count_ ) != 0;
    }
    void release() // nothrow
    {
        if( atomic_exchange_and_add( &use_count_, -1 ) == 1 )
        {
            dispose();
            weak_release();
        }
    }
    void weak_add_ref() // nothrow
    {
        atomic_increment( &weak_count_ );
    }
    void weak_release() // nothrow
    {
        if( atomic_exchange_and_add( &weak_count_, -1 ) == 1 )
        {
            destroy();
        }
    }
    long use_count() const // nothrow
    {
        return static_cast<int const volatile &>( use_count_ );
    }
 };
 } // namespace detail
 } // namespace boost
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_GCC_X86_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_counted_base_nt.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_base_nt.hpp
@@ -1,107 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_NT_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_NT_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  detail/sp_counted_base_nt.hpp
 //
 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
 //  Copyright 2004-2005 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)
 //
 #include <boost/detail/sp_typeinfo.hpp>
 namespace boost
 {
 namespace detail
 {
 class sp_counted_base
 {
 private:
    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );
    long use_count_;        // #shared
    long weak_count_;       // #weak + (#shared != 0)
 public:
    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
    {
    }
    virtual ~sp_counted_base() // nothrow
    {
    }
    // dispose() is called when use_count_ drops to zero, to release
    // the resources managed by *this.
    virtual void dispose() = 0; // nothrow
    // destroy() is called when weak_count_ drops to zero.
    virtual void destroy() // nothrow
    {
        delete this;
    }
    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
    void add_ref_copy()
    {
        ++use_count_;
    }
    bool add_ref_lock() // true on success
    {
        if( use_count_ == 0 ) return false;
        ++use_count_;
        return true;
    }
    void release() // nothrow
    {
        if( --use_count_ == 0 )
        {
            dispose();
            weak_release();
        }
    }
    void weak_add_ref() // nothrow
    {
        ++weak_count_;
    }
    void weak_release() // nothrow
    {
        if( --weak_count_ == 0 )
        {
            destroy();
        }
    }
    long use_count() const // nothrow
    {
        return use_count_;
    }
 };
 } // namespace detail
 } // namespace boost
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_NT_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_counted_base_pt.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_base_pt.hpp
@@ -1,135 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_PT_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_PT_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  detail/sp_counted_base_pt.hpp
 //
 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
 //  Copyright 2004-2005 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)
 //
 #include <boost/detail/sp_typeinfo.hpp>
 #include <pthread.h>
 namespace boost
 {
 namespace detail
 {
 class sp_counted_base
 {
 private:
    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );
    long use_count_;        // #shared
    long weak_count_;       // #weak + (#shared != 0)
    mutable pthread_mutex_t m_;
 public:
    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
    {
 // HPUX 10.20 / DCE has a nonstandard pthread_mutex_init
 #if defined(__hpux) && defined(_DECTHREADS_)
        pthread_mutex_init( &m_, pthread_mutexattr_default );
 #else
        pthread_mutex_init( &m_, 0 );
 #endif
    }
    virtual ~sp_counted_base() // nothrow
    {
        pthread_mutex_destroy( &m_ );
    }
    // dispose() is called when use_count_ drops to zero, to release
    // the resources managed by *this.
    virtual void dispose() = 0; // nothrow
    // destroy() is called when weak_count_ drops to zero.
    virtual void destroy() // nothrow
    {
        delete this;
    }
    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
    void add_ref_copy()
    {
        pthread_mutex_lock( &m_ );
        ++use_count_;
        pthread_mutex_unlock( &m_ );
    }
    bool add_ref_lock() // true on success
    {
        pthread_mutex_lock( &m_ );
        bool r = use_count_ == 0? false: ( ++use_count_, true );
        pthread_mutex_unlock( &m_ );
        return r;
    }
    void release() // nothrow
    {
        pthread_mutex_lock( &m_ );
        long new_use_count = --use_count_;
        pthread_mutex_unlock( &m_ );
        if( new_use_count == 0 )
        {
            dispose();
            weak_release();
        }
    }
    void weak_add_ref() // nothrow
    {
        pthread_mutex_lock( &m_ );
        ++weak_count_;
        pthread_mutex_unlock( &m_ );
    }
    void weak_release() // nothrow
    {
        pthread_mutex_lock( &m_ );
        long new_weak_count = --weak_count_;
        pthread_mutex_unlock( &m_ );
        if( new_weak_count == 0 )
        {
            destroy();
        }
    }
    long use_count() const // nothrow
    {
        pthread_mutex_lock( &m_ );
        long r = use_count_;
        pthread_mutex_unlock( &m_ );
        return r;
    }
 };
 } // namespace detail
 } // namespace boost
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_PT_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_counted_base_solaris.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_base_solaris.hpp
@@ -1,113 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_SOLARIS_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_SOLARIS_HPP_INCLUDED
 //
 //  detail/sp_counted_base_solaris.hpp
 //   based on: detail/sp_counted_base_w32.hpp
 //
 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
 //  Copyright 2004-2005 Peter Dimov
 //  Copyright 2006 Michael van der Westhuizen
 //
 //  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)
 //
 //
 //  Lock-free algorithm by Alexander Terekhov
 //
 //  Thanks to Ben Hitchings for the #weak + (#shared != 0)
 //  formulation
 //
 #include <boost/detail/sp_typeinfo.hpp>
 #include <atomic.h>
 namespace boost
 {
 namespace detail
 {
 class sp_counted_base
 {
 private:
    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );
    uint32_t use_count_;        // #shared
    uint32_t weak_count_;       // #weak + (#shared != 0)
 public:
    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
    {
    }
    virtual ~sp_counted_base() // nothrow
    {
    }
    // dispose() is called when use_count_ drops to zero, to release
    // the resources managed by *this.
    virtual void dispose() = 0; // nothrow
    // destroy() is called when weak_count_ drops to zero.
    virtual void destroy() // nothrow
    {
        delete this;
    }
    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
    void add_ref_copy()
    {
        atomic_inc_32( &use_count_ );
    }
    bool add_ref_lock() // true on success
    {
        for( ;; )
        {
            uint32_t tmp = static_cast< uint32_t const volatile& >( use_count_ );
            if( tmp == 0 ) return false;
            if( atomic_cas_32( &use_count_, tmp, tmp + 1 ) == tmp ) return true;
        }
    }
    void release() // nothrow
    {
        if( atomic_dec_32_nv( &use_count_ ) == 0 )
        {
            dispose();
            weak_release();
        }
    }
    void weak_add_ref() // nothrow
    {
        atomic_inc_32( &weak_count_ );
    }
    void weak_release() // nothrow
    {
        if( atomic_dec_32_nv( &weak_count_ ) == 0 )
        {
            destroy();
        }
    }
    long use_count() const // nothrow
    {
        return static_cast<long const volatile &>( use_count_ );
    }
 };
 } // namespace detail
 } // namespace boost
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_SOLARIS_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_counted_base_spin.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_base_spin.hpp
@@ -1,131 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_SPIN_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_SPIN_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  detail/sp_counted_base_spin.hpp - spinlock pool atomic emulation
 //
 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
 //  Copyright 2004-2008 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)
 //
 #include <boost/detail/sp_typeinfo.hpp>
 #include <boost/smart_ptr/detail/spinlock_pool.hpp>
 namespace boost
 {
 namespace detail
 {
 inline int atomic_exchange_and_add( int * pw, int dv )
 {
    spinlock_pool<1>::scoped_lock lock( pw );
    int r = *pw;
    *pw += dv;
    return r;
 }
 inline void atomic_increment( int * pw )
 {
    spinlock_pool<1>::scoped_lock lock( pw );
    ++*pw;
 }
 inline int atomic_conditional_increment( int * pw )
 {
    spinlock_pool<1>::scoped_lock lock( pw );
    int rv = *pw;
    if( rv != 0 ) ++*pw;
    return rv;
 }
 class sp_counted_base
 {
 private:
    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );
    int use_count_;        // #shared
    int weak_count_;       // #weak + (#shared != 0)
 public:
    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
    {
    }
    virtual ~sp_counted_base() // nothrow
    {
    }
    // dispose() is called when use_count_ drops to zero, to release
    // the resources managed by *this.
    virtual void dispose() = 0; // nothrow
    // destroy() is called when weak_count_ drops to zero.
    virtual void destroy() // nothrow
    {
        delete this;
    }
    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
    void add_ref_copy()
    {
        atomic_increment( &use_count_ );
    }
    bool add_ref_lock() // true on success
    {
        return atomic_conditional_increment( &use_count_ ) != 0;
    }
    void release() // nothrow
    {
        if( atomic_exchange_and_add( &use_count_, -1 ) == 1 )
        {
            dispose();
            weak_release();
        }
    }
    void weak_add_ref() // nothrow
    {
        atomic_increment( &weak_count_ );
    }
    void weak_release() // nothrow
    {
        if( atomic_exchange_and_add( &weak_count_, -1 ) == 1 )
        {
            destroy();
        }
    }
    long use_count() const // nothrow
    {
        spinlock_pool<1>::scoped_lock lock( &use_count_ );
        return use_count_;
    }
 };
 } // namespace detail
 } // namespace boost
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_SPIN_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_counted_base_sync.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_base_sync.hpp
@@ -1,155 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_SYNC_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_SYNC_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //  detail/sp_counted_base_sync.hpp - g++ 4.1+ __sync intrinsics
 //
 //  Copyright (c) 2007 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
 #include <boost/detail/sp_typeinfo.hpp>
 #include <limits.h>
 #if defined( __ia64__ ) && defined( __INTEL_COMPILER )
 # include <ia64intrin.h>
 #endif
 namespace boost
 {
 namespace detail
 {
 #if INT_MAX >= 2147483647
 typedef int sp_int32_t;
 #else
 typedef long sp_int32_t;
 #endif
 inline void atomic_increment( sp_int32_t * pw )
 {
    __sync_fetch_and_add( pw, 1 );
 }
 inline sp_int32_t atomic_decrement( sp_int32_t * pw )
 {
    return __sync_fetch_and_add( pw, -1 );
 }
 inline sp_int32_t atomic_conditional_increment( sp_int32_t * pw )
 {
    // long r = *pw;
    // if( r != 0 ) ++*pw;
    // return r;
    sp_int32_t r = *pw;
    for( ;; )
    {
        if( r == 0 )
        {
            return r;
        }
        sp_int32_t r2 = __sync_val_compare_and_swap( pw, r, r + 1 );
        if( r2 == r )
        {
            return r;
        }
        else
        {
            r = r2;
        }
    }    
 }
 class sp_counted_base
 {
 private:
    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );
    sp_int32_t use_count_;        // #shared
    sp_int32_t weak_count_;       // #weak + (#shared != 0)
 public:
    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
    {
    }
    virtual ~sp_counted_base() // nothrow
    {
    }
    // dispose() is called when use_count_ drops to zero, to release
    // the resources managed by *this.
    virtual void dispose() = 0; // nothrow
    // destroy() is called when weak_count_ drops to zero.
    virtual void destroy() // nothrow
    {
        delete this;
    }
    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
    void add_ref_copy()
    {
        atomic_increment( &use_count_ );
    }
    bool add_ref_lock() // true on success
    {
        return atomic_conditional_increment( &use_count_ ) != 0;
    }
    void release() // nothrow
    {
        if( atomic_decrement( &use_count_ ) == 1 )
        {
            dispose();
            weak_release();
        }
    }
    void weak_add_ref() // nothrow
    {
        atomic_increment( &weak_count_ );
    }
    void weak_release() // nothrow
    {
        if( atomic_decrement( &weak_count_ ) == 1 )
        {
            destroy();
        }
    }
    long use_count() const // nothrow
    {
        return const_cast< sp_int32_t const volatile & >( use_count_ );
    }
 };
 } // namespace detail
 } // namespace boost
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_SYNC_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_counted_base_w32.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_base_w32.hpp
@@ -1,130 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_W32_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_W32_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  detail/sp_counted_base_w32.hpp
 //
 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
 //  Copyright 2004-2005 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)
 //
 //
 //  Lock-free algorithm by Alexander Terekhov
 //
 //  Thanks to Ben Hitchings for the #weak + (#shared != 0)
 //  formulation
 //
 #include <boost/detail/interlocked.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/detail/sp_typeinfo.hpp>
 namespace boost
 {
 namespace detail
 {
 class sp_counted_base
 {
 private:
    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );
    long use_count_;        // #shared
    long weak_count_;       // #weak + (#shared != 0)
 public:
    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
    {
    }
    virtual ~sp_counted_base() // nothrow
    {
    }
    // dispose() is called when use_count_ drops to zero, to release
    // the resources managed by *this.
    virtual void dispose() = 0; // nothrow
    // destroy() is called when weak_count_ drops to zero.
    virtual void destroy() // nothrow
    {
        delete this;
    }
    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
    void add_ref_copy()
    {
        BOOST_INTERLOCKED_INCREMENT( &use_count_ );
    }
    bool add_ref_lock() // true on success
    {
        for( ;; )
        {
            long tmp = static_cast< long const volatile& >( use_count_ );
            if( tmp == 0 ) return false;
 #if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1200 )
            // work around a code generation bug
            long tmp2 = tmp + 1;
            if( BOOST_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp2, tmp ) == tmp2 - 1 ) return true;
 #else
            if( BOOST_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp + 1, tmp ) == tmp ) return true;
 #endif
        }
    }
    void release() // nothrow
    {
        if( BOOST_INTERLOCKED_DECREMENT( &use_count_ ) == 0 )
        {
            dispose();
            weak_release();
        }
    }
    void weak_add_ref() // nothrow
    {
        BOOST_INTERLOCKED_INCREMENT( &weak_count_ );
    }
    void weak_release() // nothrow
    {
        if( BOOST_INTERLOCKED_DECREMENT( &weak_count_ ) == 0 )
        {
            destroy();
        }
    }
    long use_count() const // nothrow
    {
        return static_cast<long const volatile &>( use_count_ );
    }
 };
 } // namespace detail
 } // namespace boost
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_W32_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_counted_impl.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_impl.hpp
@@ -1,231 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  detail/sp_counted_impl.hpp
 //
 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
 //  Copyright 2004-2005 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)
 //
 #include <boost/config.hpp>
 #if defined(BOOST_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR)
 # error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible.
 #endif
 #include <boost/checked_delete.hpp>
 #include <boost/smart_ptr/detail/sp_counted_base.hpp>
 #if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
 #include <boost/smart_ptr/detail/quick_allocator.hpp>
 #endif
 #if defined(BOOST_SP_USE_STD_ALLOCATOR)
 #include <memory>           // std::allocator
 #endif
 #include <cstddef>          // std::size_t
 namespace boost
 {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
 void sp_scalar_constructor_hook( void * px, std::size_t size, void * pn );
 void sp_scalar_destructor_hook( void * px, std::size_t size, void * pn );
 #endif
 namespace detail
 {
 template<class X> class sp_counted_impl_p: public sp_counted_base
 {
 private:
    X * px_;
    sp_counted_impl_p( sp_counted_impl_p const & );
    sp_counted_impl_p & operator= ( sp_counted_impl_p const & );
    typedef sp_counted_impl_p<X> this_type;
 public:
    explicit sp_counted_impl_p( X * px ): px_( px )
    {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        boost::sp_scalar_constructor_hook( px, sizeof(X), this );
 #endif
    }
    virtual void dispose() // nothrow
    {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        boost::sp_scalar_destructor_hook( px_, sizeof(X), this );
 #endif
        boost::checked_delete( px_ );
    }
    virtual void * get_deleter( detail::sp_typeinfo const & )
    {
        return 0;
    }
 #if defined(BOOST_SP_USE_STD_ALLOCATOR)
    void * operator new( std::size_t )
    {
        return std::allocator<this_type>().allocate( 1, static_cast<this_type *>(0) );
    }
    void operator delete( void * p )
    {
        std::allocator<this_type>().deallocate( static_cast<this_type *>(p), 1 );
    }
 #endif
 #if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
    void * operator new( std::size_t )
    {
        return quick_allocator<this_type>::alloc();
    }
    void operator delete( void * p )
    {
        quick_allocator<this_type>::dealloc( p );
    }
 #endif
 };
 //
 // Borland's Codeguard trips up over the -Vx- option here:
 //
 #ifdef __CODEGUARD__
 # pragma option push -Vx-
 #endif
 template<class P, class D> class sp_counted_impl_pd: public sp_counted_base
 {
 private:
    P ptr; // copy constructor must not throw
    D del; // copy constructor must not throw
    sp_counted_impl_pd( sp_counted_impl_pd const & );
    sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );
    typedef sp_counted_impl_pd<P, D> this_type;
 public:
    // pre: d(p) must not throw
    sp_counted_impl_pd( P p, D d ): ptr(p), del(d)
    {
    }
    virtual void dispose() // nothrow
    {
        del( ptr );
    }
    virtual void * get_deleter( detail::sp_typeinfo const & ti )
    {
        return ti == BOOST_SP_TYPEID(D)? &reinterpret_cast<char&>( del ): 0;
    }
 #if defined(BOOST_SP_USE_STD_ALLOCATOR)
    void * operator new( std::size_t )
    {
        return std::allocator<this_type>().allocate( 1, static_cast<this_type *>(0) );
    }
    void operator delete( void * p )
    {
        std::allocator<this_type>().deallocate( static_cast<this_type *>(p), 1 );
    }
 #endif
 #if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
    void * operator new( std::size_t )
    {
        return quick_allocator<this_type>::alloc();
    }
    void operator delete( void * p )
    {
        quick_allocator<this_type>::dealloc( p );
    }
 #endif
 };
 template<class P, class D, class A> class sp_counted_impl_pda: public sp_counted_base
 {
 private:
    P p_; // copy constructor must not throw
    D d_; // copy constructor must not throw
    A a_; // copy constructor must not throw
    sp_counted_impl_pda( sp_counted_impl_pda const & );
    sp_counted_impl_pda & operator= ( sp_counted_impl_pda const & );
    typedef sp_counted_impl_pda<P, D, A> this_type;
 public:
    // pre: d( p ) must not throw
    sp_counted_impl_pda( P p, D d, A a ): p_( p ), d_( d ), a_( a )
    {
    }
    virtual void dispose() // nothrow
    {
        d_( p_ );
    }
    virtual void destroy() // nothrow
    {
        typedef typename A::template rebind< this_type >::other A2;
        A2 a2( a_ );
        this->~this_type();
        a2.deallocate( this, 1 );
    }
    virtual void * get_deleter( detail::sp_typeinfo const & ti )
    {
        return ti == BOOST_SP_TYPEID( D )? &reinterpret_cast<char&>( d_ ): 0;
    }
 };
 #ifdef __CODEGUARD__
 # pragma option pop
 #endif
 } // namespace detail
 } // namespace boost
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_has_sync.hpp
+++ b/include/boost/smart_ptr/detail/sp_has_sync.hpp
@@ -1,49 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SP_HAS_SYNC_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SP_HAS_SYNC_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  boost/smart_ptr/detail/sp_has_sync.hpp
 //
 //  Copyright (c) 2008, 2009 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)
 //
 //  Defines the BOOST_SP_HAS_SYNC macro if the __sync_* intrinsics
 //  are available.
 //
 #if defined(__GNUC__) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 )
 #define BOOST_SP_HAS_SYNC
 #if defined( __arm__ )  || defined( __armel__ )
 #undef BOOST_SP_HAS_SYNC
 #endif
 #if defined( __hppa ) || defined( __hppa__ )
 #undef BOOST_SP_HAS_SYNC
 #endif
 #if defined( __m68k__ )
 #undef BOOST_SP_HAS_SYNC
 #endif
 #if defined( __sparc__ )
 #undef BOOST_SP_HAS_SYNC
 #endif
 #if defined( __INTEL_COMPILER ) && !defined( __ia64__ )
 #undef BOOST_SP_HAS_SYNC
 #endif
 #endif // __GNUC__ * 100 + __GNUC_MINOR__ >= 401
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_HAS_SYNC_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/spinlock.hpp
+++ b/include/boost/smart_ptr/detail/spinlock.hpp
@@ -1,53 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SPINLOCK_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  boost/detail/spinlock.hpp
 //
 //  Copyright (c) 2008 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)
 //
 //  struct spinlock
 //  {
 //      void lock();
 //      bool try_lock();
 //      void unlock();
 //
 //      class scoped_lock;
 //  };
 //
 //  #define BOOST_DETAIL_SPINLOCK_INIT <unspecified>
 //
 #include <boost/config.hpp>
 #include <boost/smart_ptr/detail/sp_has_sync.hpp>
 #if defined(__GNUC__) && defined( __arm__ ) && !defined( __thumb__ )
 #  include <boost/smart_ptr/detail/spinlock_gcc_arm.hpp>
 #elif defined( BOOST_SP_HAS_SYNC )
 #  include <boost/smart_ptr/detail/spinlock_sync.hpp>
 #elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 #  include <boost/smart_ptr/detail/spinlock_w32.hpp>
 #elif defined(BOOST_HAS_PTHREADS)
 #  include <boost/smart_ptr/detail/spinlock_pt.hpp>
 #elif !defined(BOOST_HAS_THREADS)
 #  include <boost/smart_ptr/detail/spinlock_nt.hpp>
 #else
 #  error Unrecognized threading platform
 #endif
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/spinlock_gcc_arm.hpp
+++ b/include/boost/smart_ptr/detail/spinlock_gcc_arm.hpp
@@ -1,85 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_GCC_ARM_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SPINLOCK_GCC_ARM_HPP_INCLUDED
 //
 //  Copyright (c) 2008 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)
 //
 #include <boost/smart_ptr/detail/yield_k.hpp>
 namespace boost
 {
 namespace detail
 {
 class spinlock
 {
 public:
    int v_;
 public:
    bool try_lock()
    {
        int r;
        __asm__ __volatile__(
            "swp %0, %1, [%2]":
            "=&r"( r ): // outputs
            "r"( 1 ), "r"( &v_ ): // inputs
            "memory", "cc" );
        return r == 0;
    }
    void lock()
    {
        for( unsigned k = 0; !try_lock(); ++k )
        {
            boost::detail::yield( k );
        }
    }
    void unlock()
    {
        __asm__ __volatile__( "" ::: "memory" );
        *const_cast< int volatile* >( &v_ ) = 0;
    }
 public:
    class scoped_lock
    {
    private:
        spinlock & sp_;
        scoped_lock( scoped_lock const & );
        scoped_lock & operator=( scoped_lock const & );
    public:
        explicit scoped_lock( spinlock & sp ): sp_( sp )
        {
            sp.lock();
        }
        ~scoped_lock()
        {
            sp_.unlock();
        }
    };
 };
 } // namespace detail
 } // namespace boost
 #define BOOST_DETAIL_SPINLOCK_INIT {0}
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_GCC_ARM_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/spinlock_nt.hpp
+++ b/include/boost/smart_ptr/detail/spinlock_nt.hpp
@@ -1,89 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_NT_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SPINLOCK_NT_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  Copyright (c) 2008 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)
 //
 #include <boost/assert.hpp>
 namespace boost
 {
 namespace detail
 {
 class spinlock
 {
 public:
    bool locked_;
 public:
    inline bool try_lock()
    {
        if( locked_ )
        {
            return false;
        }
        else
        {
            locked_ = true;
            return true;
        }
    }
    inline void lock()
    {
        BOOST_ASSERT( !locked_ );
        locked_ = true;
    }
    inline void unlock()
    {
        BOOST_ASSERT( locked_ );
        locked_ = false;
    }
 public:
    class scoped_lock
    {
    private:
        spinlock & sp_;
        scoped_lock( scoped_lock const & );
        scoped_lock & operator=( scoped_lock const & );
    public:
        explicit scoped_lock( spinlock & sp ): sp_( sp )
        {
            sp.lock();
        }
        ~scoped_lock()
        {
            sp_.unlock();
        }
    };
 };
 } // namespace detail
 } // namespace boost
 #define BOOST_DETAIL_SPINLOCK_INIT { false }
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_NT_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/spinlock_pool.hpp
+++ b/include/boost/smart_ptr/detail/spinlock_pool.hpp
@@ -1,87 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_POOL_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SPINLOCK_POOL_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  boost/detail/spinlock_pool.hpp
 //
 //  Copyright (c) 2008 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)
 //
 //  spinlock_pool<0> is reserved for atomic<>, when/if it arrives
 //  spinlock_pool<1> is reserved for shared_ptr reference counts
 //  spinlock_pool<2> is reserved for shared_ptr atomic access
 //
 #include <boost/config.hpp>
 #include <boost/smart_ptr/detail/spinlock.hpp>
 #include <cstddef>
 namespace boost
 {
 namespace detail
 {
 template< int I > class spinlock_pool
 {
 private:
    static spinlock pool_[ 41 ];
 public:
    static spinlock & spinlock_for( void const * pv )
    {
        std::size_t i = reinterpret_cast< std::size_t >( pv ) % 41;
        return pool_[ i ];
    }
    class scoped_lock
    {
    private:
        spinlock & sp_;
        scoped_lock( scoped_lock const & );
        scoped_lock & operator=( scoped_lock const & );
    public:
        explicit scoped_lock( void const * pv ): sp_( spinlock_for( pv ) )
        {
            sp_.lock();
        }
        ~scoped_lock()
        {
            sp_.unlock();
        }
    };
 };
 template< int I > spinlock spinlock_pool< I >::pool_[ 41 ] =
 {
    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
    BOOST_DETAIL_SPINLOCK_INIT
 };
 } // namespace detail
 } // namespace boost
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_POOL_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/spinlock_pt.hpp
+++ b/include/boost/smart_ptr/detail/spinlock_pt.hpp
@@ -1,79 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_PT_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SPINLOCK_PT_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  Copyright (c) 2008 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)
 //
 #include <pthread.h>
 namespace boost
 {
 namespace detail
 {
 class spinlock
 {
 public:
    pthread_mutex_t v_;
 public:
    bool try_lock()
    {
        return pthread_mutex_trylock( &v_ ) == 0;
    }
    void lock()
    {
        pthread_mutex_lock( &v_ );
    }
    void unlock()
    {
        pthread_mutex_unlock( &v_ );
    }
 public:
    class scoped_lock
    {
    private:
        spinlock & sp_;
        scoped_lock( scoped_lock const & );
        scoped_lock & operator=( scoped_lock const & );
    public:
        explicit scoped_lock( spinlock & sp ): sp_( sp )
        {
            sp.lock();
        }
        ~scoped_lock()
        {
            sp_.unlock();
        }
    };
 };
 } // namespace detail
 } // namespace boost
 #define BOOST_DETAIL_SPINLOCK_INIT { PTHREAD_MUTEX_INITIALIZER }
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_PT_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/spinlock_sync.hpp
+++ b/include/boost/smart_ptr/detail/spinlock_sync.hpp
@@ -1,87 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_SYNC_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SPINLOCK_SYNC_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  Copyright (c) 2008 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)
 //
 #include <boost/smart_ptr/detail/yield_k.hpp>
 #if defined( __ia64__ ) && defined( __INTEL_COMPILER )
 # include <ia64intrin.h>
 #endif
 namespace boost
 {
 namespace detail
 {
 class spinlock
 {
 public:
    int v_;
 public:
    bool try_lock()
    {
        int r = __sync_lock_test_and_set( &v_, 1 );
        return r == 0;
    }
    void lock()
    {
        for( unsigned k = 0; !try_lock(); ++k )
        {
            boost::detail::yield( k );
        }
    }
    void unlock()
    {
        __sync_lock_release( &v_ );
    }
 public:
    class scoped_lock
    {
    private:
        spinlock & sp_;
        scoped_lock( scoped_lock const & );
        scoped_lock & operator=( scoped_lock const & );
    public:
        explicit scoped_lock( spinlock & sp ): sp_( sp )
        {
            sp.lock();
        }
        ~scoped_lock()
        {
            sp_.unlock();
        }
    };
 };
 } // namespace detail
 } // namespace boost
 #define BOOST_DETAIL_SPINLOCK_INIT {0}
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_SYNC_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/spinlock_w32.hpp
+++ b/include/boost/smart_ptr/detail/spinlock_w32.hpp
@@ -1,113 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_W32_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_SPINLOCK_W32_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  Copyright (c) 2008 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)
 //
 #include <boost/detail/interlocked.hpp>
 #include <boost/smart_ptr/detail/yield_k.hpp>
 // BOOST_COMPILER_FENCE
 #if defined(__INTEL_COMPILER)
 #define BOOST_COMPILER_FENCE __memory_barrier();
 #elif defined( _MSC_VER ) && _MSC_VER >= 1310
 extern "C" void _ReadWriteBarrier();
 #pragma intrinsic( _ReadWriteBarrier )
 #define BOOST_COMPILER_FENCE _ReadWriteBarrier();
 #elif defined(__GNUC__)
 #define BOOST_COMPILER_FENCE __asm__ __volatile__( "" : : : "memory" );
 #else
 #define BOOST_COMPILER_FENCE
 #endif
 //
 namespace boost
 {
 namespace detail
 {
 class spinlock
 {
 public:
    long v_;
 public:
    bool try_lock()
    {
        long r = BOOST_INTERLOCKED_EXCHANGE( &v_, 1 );
        BOOST_COMPILER_FENCE
        return r == 0;
    }
    void lock()
    {
        for( unsigned k = 0; !try_lock(); ++k )
        {
            boost::detail::yield( k );
        }
    }
    void unlock()
    {
        BOOST_COMPILER_FENCE
        *const_cast< long volatile* >( &v_ ) = 0;
    }
 public:
    class scoped_lock
    {
    private:
        spinlock & sp_;
        scoped_lock( scoped_lock const & );
        scoped_lock & operator=( scoped_lock const & );
    public:
        explicit scoped_lock( spinlock & sp ): sp_( sp )
        {
            sp.lock();
        }
        ~scoped_lock()
        {
            sp_.unlock();
        }
    };
 };
 } // namespace detail
 } // namespace boost
 #define BOOST_DETAIL_SPINLOCK_INIT {0}
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_W32_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/yield_k.hpp
+++ b/include/boost/smart_ptr/detail/yield_k.hpp
@@ -1,149 +0,0 @@
 #ifndef BOOST_SMART_PTR_DETAIL_YIELD_K_HPP_INCLUDED
 #define BOOST_SMART_PTR_DETAIL_YIELD_K_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  yield_k.hpp
 //
 //  Copyright (c) 2008 Peter Dimov
 //
 //  void yield( unsigned k );
 //
 //  Typical use:
 //
 //  for( unsigned k = 0; !try_lock(); ++k ) yield( k );
 //
 //  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
 //
 #include <boost/config.hpp>
 // BOOST_SMT_PAUSE
 #if defined(_MSC_VER) && _MSC_VER >= 1310 && ( defined(_M_IX86) || defined(_M_X64) )
 extern "C" void _mm_pause();
 #pragma intrinsic( _mm_pause )
 #define BOOST_SMT_PAUSE _mm_pause();
 #elif defined(__GNUC__) && ( defined(__i386__) || defined(__x86_64__) )
 #define BOOST_SMT_PAUSE __asm__ __volatile__( "rep; nop" : : : "memory" );
 #endif
 //
 #if defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ )
 #if defined( BOOST_USE_WINDOWS_H )
 # include <windows.h>
 #endif
 namespace boost
 {
 namespace detail
 {
 #if !defined( BOOST_USE_WINDOWS_H )
  extern "C" void __stdcall Sleep( unsigned ms );
 #endif
 inline void yield( unsigned k )
 {
    if( k < 4 )
    {
    }
 #if defined( BOOST_SMT_PAUSE )
    else if( k < 16 )
    {
        BOOST_SMT_PAUSE
    }
 #endif
    else if( k < 32 )
    {
        Sleep( 0 );
    }
    else
    {
        Sleep( 1 );
    }
 }
 } // namespace detail
 } // namespace boost
 #elif defined( BOOST_HAS_PTHREADS )
 #include <sched.h>
 #include <time.h>
 namespace boost
 {
 namespace detail
 {
 inline void yield( unsigned k )
 {
    if( k < 4 )
    {
    }
 #if defined( BOOST_SMT_PAUSE )
    else if( k < 16 )
    {
        BOOST_SMT_PAUSE
    }
 #endif
    else if( k < 32 || k & 1 )
    {
        sched_yield();
    }
    else
    {
        // g++ -Wextra warns on {} or {0}
        struct timespec rqtp = { 0, 0 };
        // POSIX says that timespec has tv_sec and tv_nsec
        // But it doesn't guarantee order or placement
        rqtp.tv_sec = 0;
        rqtp.tv_nsec = 1000;
        nanosleep( &rqtp, 0 );
    }
 }
 } // namespace detail
 } // namespace boost
 #else
 namespace boost
 {
 namespace detail
 {
 inline void yield( unsigned )
 {
 }
 } // namespace detail
 } // namespace boost
 #endif
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_YIELD_K_HPP_INCLUDED
--- a/include/boost/smart_ptr/enable_shared_from_this.hpp
+++ b/include/boost/smart_ptr/enable_shared_from_this.hpp
@@ -1,79 +0,0 @@
 #ifndef BOOST_SMART_PTR_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
 #define BOOST_SMART_PTR_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
 //
 //  enable_shared_from_this.hpp
 //
 //  Copyright 2002, 2009 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
 //
 //  http://www.boost.org/libs/smart_ptr/enable_shared_from_this.html
 //
 #include <boost/smart_ptr/weak_ptr.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
 namespace boost
 {
 template<class T> class enable_shared_from_this
 {
 protected:
    enable_shared_from_this()
    {
    }
    enable_shared_from_this(enable_shared_from_this const &)
    {
    }
    enable_shared_from_this & operator=(enable_shared_from_this const &)
    {
        return *this;
    }
    ~enable_shared_from_this()
    {
    }
 public:
    shared_ptr<T> shared_from_this()
    {
        shared_ptr<T> p( weak_this_ );
        BOOST_ASSERT( p.get() == this );
        return p;
    }
    shared_ptr<T const> shared_from_this() const
    {
        shared_ptr<T const> p( weak_this_ );
        BOOST_ASSERT( p.get() == this );
        return p;
    }
 public: // actually private, but avoids compiler template friendship issues
    // Note: invoked automatically by shared_ptr; do not call
    template<class X, class Y> void _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const
    {
        if( weak_this_.expired() )
        {
            weak_this_ = shared_ptr<T>( *ppx, py );
        }
    }
 private:
    mutable weak_ptr<T> weak_this_;
 };
 } // namespace boost
 #endif  // #ifndef BOOST_SMART_PTR_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
--- a/include/boost/smart_ptr/enable_shared_from_this2.hpp
+++ b/include/boost/smart_ptr/enable_shared_from_this2.hpp
@@ -1,132 +0,0 @@
 #ifndef BOOST_ENABLE_SHARED_FROM_THIS2_HPP_INCLUDED
 #define BOOST_ENABLE_SHARED_FROM_THIS2_HPP_INCLUDED
 //
 //  enable_shared_from_this2.hpp
 //
 //  Copyright 2002, 2009 Peter Dimov
 //  Copyright 2008 Frank Mori Hess
 //
 //  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
 //
 #include <boost/config.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/assert.hpp>
 #include <boost/detail/workaround.hpp>
 namespace boost
 {
 namespace detail
 {
 class esft2_deleter_wrapper
 {
 private:
    shared_ptr<void> deleter_;
 public:
    esft2_deleter_wrapper()
    {
    }
    template< class T > void set_deleter( shared_ptr<T> const & deleter )
    {
        deleter_ = deleter;
    }
    template< class T> void operator()( T* )
    {
        BOOST_ASSERT( deleter_.use_count() <= 1 );
        deleter_.reset();
    }
 };
 } // namespace detail
 template< class T > class enable_shared_from_this2
 {
 protected:
    enable_shared_from_this2()
    {
    }
    enable_shared_from_this2( enable_shared_from_this2 const & )
    {
    }
    enable_shared_from_this2 & operator=( enable_shared_from_this2 const & )
    {
        return *this;
    }
    ~enable_shared_from_this2()
    {
        BOOST_ASSERT( shared_this_.use_count() <= 1 ); // make sure no dangling shared_ptr objects exist
    }
 private:
    mutable weak_ptr<T> weak_this_;
    mutable shared_ptr<T> shared_this_;
 public:
    shared_ptr<T> shared_from_this()
    {
        init_weak_once();
        return shared_ptr<T>( weak_this_ );
    }
    shared_ptr<T const> shared_from_this() const
    {
        init_weak_once();
        return shared_ptr<T>( weak_this_ );
    }
 private:
    void init_weak_once() const
    {
        if( weak_this_._empty() )
        {
            shared_this_.reset( static_cast< T* >( 0 ), detail::esft2_deleter_wrapper() );
            weak_this_ = shared_this_;
        }
    }
 public: // actually private, but avoids compiler template friendship issues
    // Note: invoked automatically by shared_ptr; do not call
    template<class X, class Y> void _internal_accept_owner( shared_ptr<X> * ppx, Y * py ) const
    {
        BOOST_ASSERT( ppx != 0 );
        if( weak_this_.use_count() == 0 )
        {
            weak_this_ = shared_ptr<T>( *ppx, py );
        }
        else if( shared_this_.use_count() != 0 )
        {
            BOOST_ASSERT( ppx->unique() ); // no weak_ptrs should exist either, but there's no way to check that
            detail::esft2_deleter_wrapper * pd = boost::get_deleter<detail::esft2_deleter_wrapper>( shared_this_ );
            BOOST_ASSERT( pd != 0 );
            pd->set_deleter( *ppx );
            ppx->reset( shared_this_, ppx->get() );
            shared_this_.reset();
        }
    }
 };
 } // namespace boost
 #endif  // #ifndef BOOST_ENABLE_SHARED_FROM_THIS2_HPP_INCLUDED
--- a/include/boost/smart_ptr/intrusive_ptr.hpp
+++ b/include/boost/smart_ptr/intrusive_ptr.hpp
@@ -1,299 +0,0 @@
 #ifndef BOOST_SMART_PTR_INTRUSIVE_PTR_HPP_INCLUDED
 #define BOOST_SMART_PTR_INTRUSIVE_PTR_HPP_INCLUDED
 //
 //  intrusive_ptr.hpp
 //
 //  Copyright (c) 2001, 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)
 //
 //  See http://www.boost.org/libs/smart_ptr/intrusive_ptr.html for documentation.
 //
 #include <boost/config.hpp>
 #ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
 # pragma warning(push)
 # pragma warning(disable:4284) // odd return type for operator->
 #endif
 #include <boost/assert.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/smart_ptr/detail/sp_convertible.hpp>
 #include <boost/config/no_tr1/functional.hpp>           // for std::less
 #if !defined(BOOST_NO_IOSTREAM)
 #if !defined(BOOST_NO_IOSFWD)
 #include <iosfwd>               // for std::basic_ostream
 #else
 #include <ostream>
 #endif
 #endif
 namespace boost
 {
 //
 //  intrusive_ptr
 //
 //  A smart pointer that uses intrusive reference counting.
 //
 //  Relies on unqualified calls to
 //  
 //      void intrusive_ptr_add_ref(T * p);
 //      void intrusive_ptr_release(T * p);
 //
 //          (p != 0)
 //
 //  The object is responsible for destroying itself.
 //
 template<class T> class intrusive_ptr
 {
 private:
    typedef intrusive_ptr this_type;
 public:
    typedef T element_type;
    intrusive_ptr(): px( 0 )
    {
    }
    intrusive_ptr( T * p, bool add_ref = true ): px( p )
    {
        if( px != 0 && add_ref ) intrusive_ptr_add_ref( px );
    }
 #if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
    template<class U>
 #if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
    intrusive_ptr( intrusive_ptr<U> const & rhs, typename detail::sp_enable_if_convertible<U,T>::type = detail::sp_empty() )
 #else
    intrusive_ptr( intrusive_ptr<U> const & rhs )
 #endif
    : px( rhs.get() )
    {
        if( px != 0 ) intrusive_ptr_add_ref( px );
    }
 #endif
    intrusive_ptr(intrusive_ptr const & rhs): px( rhs.px )
    {
        if( px != 0 ) intrusive_ptr_add_ref( px );
    }
    ~intrusive_ptr()
    {
        if( px != 0 ) intrusive_ptr_release( px );
    }
 #if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
    template<class U> intrusive_ptr & operator=(intrusive_ptr<U> const & rhs)
    {
        this_type(rhs).swap(*this);
        return *this;
    }
 #endif
 // Move support
 #if defined( BOOST_HAS_RVALUE_REFS )
    intrusive_ptr(intrusive_ptr && rhs): px( rhs.px )
    {
        rhs.px = 0;
    }
    intrusive_ptr & operator=(intrusive_ptr && rhs)
    {
        this_type(std::move(rhs)).swap(*this);
        return *this;
    }
 #endif
    intrusive_ptr & operator=(intrusive_ptr const & rhs)
    {
        this_type(rhs).swap(*this);
        return *this;
    }
    intrusive_ptr & operator=(T * rhs)
    {
        this_type(rhs).swap(*this);
        return *this;
    }
    void reset()
    {
        this_type().swap( *this );
    }
    void reset( T * rhs )
    {
        this_type( rhs ).swap( *this );
    }
    T * get() const
    {
        return px;
    }
    T & operator*() const
    {
        BOOST_ASSERT( px != 0 );
        return *px;
    }
    T * operator->() const
    {
        BOOST_ASSERT( px != 0 );
        return px;
    }
 // implicit conversion to "bool"
 #include <boost/smart_ptr/detail/operator_bool.hpp>
    void swap(intrusive_ptr & rhs)
    {
        T * tmp = px;
        px = rhs.px;
        rhs.px = tmp;
    }
 private:
    T * px;
 };
 template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b)
 {
    return a.get() == b.get();
 }
 template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b)
 {
    return a.get() != b.get();
 }
 template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, U * b)
 {
    return a.get() == b;
 }
 template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, U * b)
 {
    return a.get() != b;
 }
 template<class T, class U> inline bool operator==(T * a, intrusive_ptr<U> const & b)
 {
    return a == b.get();
 }
 template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const & b)
 {
    return a != b.get();
 }
 #if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
 // Resolve the ambiguity between our op!= and the one in rel_ops
 template<class T> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
 {
    return a.get() != b.get();
 }
 #endif
 template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
 {
    return std::less<T *>()(a.get(), b.get());
 }
 template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs)
 {
    lhs.swap(rhs);
 }
 // mem_fn support
 template<class T> T * get_pointer(intrusive_ptr<T> const & p)
 {
    return p.get();
 }
 template<class T, class U> intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const & p)
 {
    return static_cast<T *>(p.get());
 }
 template<class T, class U> intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U> const & p)
 {
    return const_cast<T *>(p.get());
 }
 template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> const & p)
 {
    return dynamic_cast<T *>(p.get());
 }
 // operator<<
 #if !defined(BOOST_NO_IOSTREAM)
 #if defined(BOOST_NO_TEMPLATED_IOSTREAMS) || ( defined(__GNUC__) &&  (__GNUC__ < 3) )
 template<class Y> std::ostream & operator<< (std::ostream & os, intrusive_ptr<Y> const & p)
 {
    os << p.get();
    return os;
 }
 #else
 // in STLport's no-iostreams mode no iostream symbols can be used
 #ifndef _STLP_NO_IOSTREAMS
 # if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300 && __SGI_STL_PORT)
 // MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL
 using std::basic_ostream;
 template<class E, class T, class Y> basic_ostream<E, T> & operator<< (basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)
 # else
 template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)
 # endif 
 {
    os << p.get();
    return os;
 }
 #endif // _STLP_NO_IOSTREAMS
 #endif // __GNUC__ < 3
 #endif // !defined(BOOST_NO_IOSTREAM)
 } // namespace boost
 #ifdef BOOST_MSVC
 # pragma warning(pop)
 #endif    
 #endif  // #ifndef BOOST_SMART_PTR_INTRUSIVE_PTR_HPP_INCLUDED
--- a/include/boost/smart_ptr/make_shared.hpp
+++ b/include/boost/smart_ptr/make_shared.hpp
@@ -1,504 +0,0 @@
 #ifndef BOOST_SMART_PTR_MAKE_SHARED_HPP_INCLUDED
 #define BOOST_SMART_PTR_MAKE_SHARED_HPP_INCLUDED
 //  make_shared.hpp
 //
 //  Copyright (c) 2007, 2008 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
 //
 //  See http://www.boost.org/libs/smart_ptr/make_shared.html
 //  for documentation.
 #include <boost/config.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
 #include <boost/type_traits/type_with_alignment.hpp>
 #include <boost/type_traits/alignment_of.hpp>
 #include <cstddef>
 #include <new>
 namespace boost
 {
 namespace detail
 {
 template< std::size_t N, std::size_t A > struct sp_aligned_storage
 {
    union type
    {
        char data_[ N ];
        typename boost::type_with_alignment< A >::type align_;
    };
 };
 template< class T > class sp_ms_deleter
 {
 private:
    typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
    bool initialized_;
    storage_type storage_;
 private:
    void destroy()
    {
        if( initialized_ )
        {
            reinterpret_cast< T* >( storage_.data_ )->~T();
            initialized_ = false;
        }
    }
 public:
    sp_ms_deleter(): initialized_( false )
    {
    }
    // optimization: do not copy storage_
    sp_ms_deleter( sp_ms_deleter const & ): initialized_( false )
    {
    }
    ~sp_ms_deleter()
    {
        destroy();
    }
    void operator()( T * )
    {
        destroy();
    }
    void * address()
    {
        return storage_.data_;
    }
    void set_initialized()
    {
        initialized_ = true;
    }
 };
 template< class T > T forward( T t )
 {
    return t;
 }
 } // namespace detail
 // Zero-argument versions
 //
 // Used even when variadic templates are available because of the new T() vs new T issue
 template< class T > boost::shared_ptr< T > make_shared()
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T();
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A > boost::shared_ptr< T > allocate_shared( A const & a )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T();
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 #if defined( BOOST_HAS_VARIADIC_TMPL ) && defined( BOOST_HAS_RVALUE_REFS )
 // Variadic templates, rvalue reference
 template< class T, class... Args > boost::shared_ptr< T > make_shared( Args && ... args )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( detail::forward<Args>( args )... );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A, class... Args > boost::shared_ptr< T > allocate_shared( A const & a, Args && ... args )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( detail::forward<Args>( args )... );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 #else
 // C++03 version
 template< class T, class A1 >
 boost::shared_ptr< T > make_shared( A1 const & a1 )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( a1 );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A, class A1 >
 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1 )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( a1 );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A1, class A2 >
 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2 )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( a1, a2 );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A, class A1, class A2 >
 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2 )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( a1, a2 );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A1, class A2, class A3 >
 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3 )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( a1, a2, a3 );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A, class A1, class A2, class A3 >
 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3 )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( a1, a2, a3 );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A1, class A2, class A3, class A4 >
 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( a1, a2, a3, a4 );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A, class A1, class A2, class A3, class A4 >
 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( a1, a2, a3, a4 );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A1, class A2, class A3, class A4, class A5 >
 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( a1, a2, a3, a4, a5 );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( a1, a2, a3, a4, a5 );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( a1, a2, a3, a4, a5, a6 );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( a1, a2, a3, a4, a5, a6 );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
 {
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
    void * pv = pd->address();
    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
    pd->set_initialized();
    T * pt2 = static_cast< T* >( pv );
    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
 }
 #endif
 } // namespace boost
 #endif // #ifndef BOOST_SMART_PTR_MAKE_SHARED_HPP_INCLUDED
--- a/include/boost/smart_ptr/scoped_array.hpp
+++ b/include/boost/smart_ptr/scoped_array.hpp
@@ -1,107 +0,0 @@
 #ifndef BOOST_SMART_PTR_SCOPED_ARRAY_HPP_INCLUDED
 #define BOOST_SMART_PTR_SCOPED_ARRAY_HPP_INCLUDED
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
 //  Copyright (c) 2001, 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)
 //
 //  http://www.boost.org/libs/smart_ptr/scoped_array.htm
 //
 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/config.hpp>   // in case ptrdiff_t not in std
 #include <boost/detail/workaround.hpp>
 #include <cstddef>            // for std::ptrdiff_t
 namespace boost
 {
 // Debug hooks
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
 void sp_array_constructor_hook(void * p);
 void sp_array_destructor_hook(void * p);
 #endif
 //  scoped_array extends scoped_ptr to arrays. Deletion of the array pointed to
 //  is guaranteed, either on destruction of the scoped_array or via an explicit
 //  reset(). Use shared_array or std::vector if your needs are more complex.
 template<class T> class scoped_array // noncopyable
 {
 private:
    T * px;
    scoped_array(scoped_array const &);
    scoped_array & operator=(scoped_array const &);
    typedef scoped_array<T> this_type;
    void operator==( scoped_array const& ) const;
    void operator!=( scoped_array const& ) const;
 public:
    typedef T element_type;
    explicit scoped_array( T * p = 0 ) : px( p ) // never throws
    {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        boost::sp_array_constructor_hook( px );
 #endif
    }
    ~scoped_array() // never throws
    {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        boost::sp_array_destructor_hook( px );
 #endif
        boost::checked_array_delete( px );
    }
    void reset(T * p = 0) // never throws
    {
        BOOST_ASSERT( p == 0 || p != px ); // catch self-reset errors
        this_type(p).swap(*this);
    }
    T & operator[](std::ptrdiff_t i) const // never throws
    {
        BOOST_ASSERT( px != 0 );
        BOOST_ASSERT( i >= 0 );
        return px[i];
    }
    T * get() const // never throws
    {
        return px;
    }
 // implicit conversion to "bool"
 #include <boost/smart_ptr/detail/operator_bool.hpp>
    void swap(scoped_array & b) // never throws
    {
        T * tmp = b.px;
        b.px = px;
        px = tmp;
    }
 };
 template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) // never throws
 {
    a.swap(b);
 }
 } // namespace boost
 #endif  // #ifndef BOOST_SMART_PTR_SCOPED_ARRAY_HPP_INCLUDED
--- a/include/boost/smart_ptr/scoped_ptr.hpp
+++ b/include/boost/smart_ptr/scoped_ptr.hpp
@@ -1,131 +0,0 @@
 #ifndef BOOST_SMART_PTR_SCOPED_PTR_HPP_INCLUDED
 #define BOOST_SMART_PTR_SCOPED_PTR_HPP_INCLUDED
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
 //  Copyright (c) 2001, 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)
 //
 //  http://www.boost.org/libs/smart_ptr/scoped_ptr.htm
 //
 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/detail/workaround.hpp>
 #ifndef BOOST_NO_AUTO_PTR
 # include <memory>          // for std::auto_ptr
 #endif
 namespace boost
 {
 // Debug hooks
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
 void sp_scalar_constructor_hook(void * p);
 void sp_scalar_destructor_hook(void * p);
 #endif
 //  scoped_ptr mimics a built-in pointer except that it guarantees deletion
 //  of the object pointed to, either on destruction of the scoped_ptr or via
 //  an explicit reset(). scoped_ptr is a simple solution for simple needs;
 //  use shared_ptr or std::auto_ptr if your needs are more complex.
 template<class T> class scoped_ptr // noncopyable
 {
 private:
    T * px;
    scoped_ptr(scoped_ptr const &);
    scoped_ptr & operator=(scoped_ptr const &);
    typedef scoped_ptr<T> this_type;
    void operator==( scoped_ptr const& ) const;
    void operator!=( scoped_ptr const& ) const;
 public:
    typedef T element_type;
    explicit scoped_ptr( T * p = 0 ): px( p ) // never throws
    {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        boost::sp_scalar_constructor_hook( px );
 #endif
    }
 #ifndef BOOST_NO_AUTO_PTR
    explicit scoped_ptr( std::auto_ptr<T> p ): px( p.release() ) // never throws
    {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        boost::sp_scalar_constructor_hook( px );
 #endif
    }
 #endif
    ~scoped_ptr() // never throws
    {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        boost::sp_scalar_destructor_hook( px );
 #endif
        boost::checked_delete( px );
    }
    void reset(T * p = 0) // never throws
    {
        BOOST_ASSERT( p == 0 || p != px ); // catch self-reset errors
        this_type(p).swap(*this);
    }
    T & operator*() const // never throws
    {
        BOOST_ASSERT( px != 0 );
        return *px;
    }
    T * operator->() const // never throws
    {
        BOOST_ASSERT( px != 0 );
        return px;
    }
    T * get() const // never throws
    {
        return px;
    }
 // implicit conversion to "bool"
 #include <boost/smart_ptr/detail/operator_bool.hpp>
    void swap(scoped_ptr & b) // never throws
    {
        T * tmp = b.px;
        b.px = px;
        px = tmp;
    }
 };
 template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) // never throws
 {
    a.swap(b);
 }
 // get_pointer(p) is a generic way to say p.get()
 template<class T> inline T * get_pointer(scoped_ptr<T> const & p)
 {
    return p.get();
 }
 } // namespace boost
 #endif // #ifndef BOOST_SMART_PTR_SCOPED_PTR_HPP_INCLUDED
--- a/include/boost/smart_ptr/shared_array.hpp
+++ b/include/boost/smart_ptr/shared_array.hpp
@@ -1,147 +0,0 @@
 #ifndef BOOST_SMART_PTR_SHARED_ARRAY_HPP_INCLUDED
 #define BOOST_SMART_PTR_SHARED_ARRAY_HPP_INCLUDED
 //
 //  shared_array.hpp
 //
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
 //  Copyright (c) 2001, 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)
 //
 //  See http://www.boost.org/libs/smart_ptr/shared_array.htm for documentation.
 //
 #include <boost/config.hpp>   // for broken compiler workarounds
 #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
 #include <boost/smart_ptr/detail/shared_array_nmt.hpp>
 #else
 #include <memory>             // TR1 cyclic inclusion fix
 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/smart_ptr/detail/shared_count.hpp>
 #include <boost/detail/workaround.hpp>
 #include <cstddef>            // for std::ptrdiff_t
 #include <algorithm>          // for std::swap
 #include <functional>         // for std::less
 namespace boost
 {
 //
 //  shared_array
 //
 //  shared_array extends shared_ptr to arrays.
 //  The array pointed to is deleted when the last shared_array pointing to it
 //  is destroyed or reset.
 //
 template<class T> class shared_array
 {
 private:
    // Borland 5.5.1 specific workarounds
    typedef checked_array_deleter<T> deleter;
    typedef shared_array<T> this_type;
 public:
    typedef T element_type;
    explicit shared_array(T * p = 0): px(p), pn(p, deleter())
    {
    }
    //
    // Requirements: D's copy constructor must not throw
    //
    // shared_array will release p by calling d(p)
    //
    template<class D> shared_array(T * p, D d): px(p), pn(p, d)
    {
    }
 //  generated copy constructor, assignment, destructor are fine
    void reset(T * p = 0)
    {
        BOOST_ASSERT(p == 0 || p != px);
        this_type(p).swap(*this);
    }
    template <class D> void reset(T * p, D d)
    {
        this_type(p, d).swap(*this);
    }
    T & operator[] (std::ptrdiff_t i) const // never throws
    {
        BOOST_ASSERT(px != 0);
        BOOST_ASSERT(i >= 0);
        return px[i];
    }
    T * get() const // never throws
    {
        return px;
    }
 // implicit conversion to "bool"
 #include <boost/smart_ptr/detail/operator_bool.hpp>
    bool unique() const // never throws
    {
        return pn.unique();
    }
    long use_count() const // never throws
    {
        return pn.use_count();
    }
    void swap(shared_array<T> & other) // never throws
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }
 private:
    T * px;                     // contained pointer
    detail::shared_count pn;    // reference counter
 };  // shared_array
 template<class T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) // never throws
 {
    return a.get() == b.get();
 }
 template<class T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) // never throws
 {
    return a.get() != b.get();
 }
 template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) // never throws
 {
    return std::less<T*>()(a.get(), b.get());
 }
 template<class T> void swap(shared_array<T> & a, shared_array<T> & b) // never throws
 {
    a.swap(b);
 }
 } // namespace boost
 #endif  // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
 #endif  // #ifndef BOOST_SMART_PTR_SHARED_ARRAY_HPP_INCLUDED
--- a/include/boost/smart_ptr/shared_ptr.hpp
+++ b/include/boost/smart_ptr/shared_ptr.hpp
@@ -1,701 +0,0 @@
 #ifndef BOOST_SMART_PTR_SHARED_PTR_HPP_INCLUDED
 #define BOOST_SMART_PTR_SHARED_PTR_HPP_INCLUDED
 //
 //  shared_ptr.hpp
 //
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
 //  Copyright (c) 2001-2008 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)
 //
 //  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
 //
 #include <boost/config.hpp>   // for broken compiler workarounds
 #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
 #include <boost/smart_ptr/detail/shared_ptr_nmt.hpp>
 #else
 // In order to avoid circular dependencies with Boost.TR1
 // we make sure that our include of <memory> doesn't try to
 // pull in the TR1 headers: that's why we use this header 
 // rather than including <memory> directly:
 #include <boost/config/no_tr1/memory.hpp>  // std::auto_ptr
 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/throw_exception.hpp>
 #include <boost/smart_ptr/detail/shared_count.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/smart_ptr/detail/sp_convertible.hpp>
 #if !defined(BOOST_SP_NO_ATOMIC_ACCESS)
 #include <boost/smart_ptr/detail/spinlock_pool.hpp>
 #include <boost/memory_order.hpp>
 #endif
 #include <algorithm>            // for std::swap
 #include <functional>           // for std::less
 #include <typeinfo>             // for std::bad_cast
 #if !defined(BOOST_NO_IOSTREAM)
 #if !defined(BOOST_NO_IOSFWD)
 #include <iosfwd>               // for std::basic_ostream
 #else
 #include <ostream>
 #endif
 #endif
 #ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
 # pragma warning(push)
 # pragma warning(disable:4284) // odd return type for operator->
 #endif
 namespace boost
 {
 template<class T> class shared_ptr;
 template<class T> class weak_ptr;
 template<class T> class enable_shared_from_this;
 template<class T> class enable_shared_from_this2;
 namespace detail
 {
 struct static_cast_tag {};
 struct const_cast_tag {};
 struct dynamic_cast_tag {};
 struct polymorphic_cast_tag {};
 template<class T> struct shared_ptr_traits
 {
    typedef T & reference;
 };
 template<> struct shared_ptr_traits<void>
 {
    typedef void reference;
 };
 #if !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)
 template<> struct shared_ptr_traits<void const>
 {
    typedef void reference;
 };
 template<> struct shared_ptr_traits<void volatile>
 {
    typedef void reference;
 };
 template<> struct shared_ptr_traits<void const volatile>
 {
    typedef void reference;
 };
 #endif
 // enable_shared_from_this support
 template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
 {
    if( pe != 0 )
    {
        pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
    }
 }
 template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_this2< T > const * pe )
 {
    if( pe != 0 )
    {
        pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
    }
 }
 #ifdef _MANAGED
 // Avoid C4793, ... causes native code generation
 struct sp_any_pointer
 {
    template<class T> sp_any_pointer( T* ) {}
 };
 inline void sp_enable_shared_from_this( sp_any_pointer, sp_any_pointer, sp_any_pointer )
 {
 }
 #else // _MANAGED
 inline void sp_enable_shared_from_this( ... )
 {
 }
 #endif // _MANAGED
 #if !defined( BOOST_NO_SFINAE ) && !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined( BOOST_NO_AUTO_PTR )
 // rvalue auto_ptr support based on a technique by Dave Abrahams
 template< class T, class R > struct sp_enable_if_auto_ptr
 {
 };
 template< class T, class R > struct sp_enable_if_auto_ptr< std::auto_ptr< T >, R >
 {
    typedef R type;
 }; 
 #endif
 } // namespace detail
 //
 //  shared_ptr
 //
 //  An enhanced relative of scoped_ptr with reference counted copy semantics.
 //  The object pointed to is deleted when the last shared_ptr pointing to it
 //  is destroyed or reset.
 //
 template<class T> class shared_ptr
 {
 private:
    // Borland 5.5.1 specific workaround
    typedef shared_ptr<T> this_type;
 public:
    typedef T element_type;
    typedef T value_type;
    typedef T * pointer;
    typedef typename boost::detail::shared_ptr_traits<T>::reference reference;
    shared_ptr(): px(0), pn() // never throws in 1.30+
    {
    }
    template<class Y>
    explicit shared_ptr( Y * p ): px( p ), pn( p ) // Y must be complete
    {
        boost::detail::sp_enable_shared_from_this( this, p, p );
    }
    //
    // Requirements: D's copy constructor must not throw
    //
    // shared_ptr will release p by calling d(p)
    //
    template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
    {
        boost::detail::sp_enable_shared_from_this( this, p, p );
    }
    // As above, but with allocator. A's copy constructor shall not throw.
    template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
    {
        boost::detail::sp_enable_shared_from_this( this, p, p );
    }
 //  generated copy constructor, destructor are fine
    template<class Y>
    explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn) // may throw
    {
        // it is now safe to copy r.px, as pn(r.pn) did not throw
        px = r.px;
    }
    template<class Y>
    shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag ): px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() ) // never throws
    {
        if( !pn.empty() )
        {
            px = r.px;
        }
    }
    template<class Y>
 #if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
    shared_ptr( shared_ptr<Y> const & r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
 #else
    shared_ptr( shared_ptr<Y> const & r )
 #endif
    : px( r.px ), pn( r.pn ) // never throws
    {
    }
    // aliasing
    template< class Y >
    shared_ptr( shared_ptr<Y> const & r, T * p ): px( p ), pn( r.pn ) // never throws
    {
    }
    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
    {
    }
    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn)
    {
    }
    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
    {
        if(px == 0) // need to allocate new counter -- the cast failed
        {
            pn = boost::detail::shared_count();
        }
    }
    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
    {
        if(px == 0)
        {
            boost::throw_exception(std::bad_cast());
        }
    }
 #ifndef BOOST_NO_AUTO_PTR
    template<class Y>
    explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
    {
        Y * tmp = r.get();
        pn = boost::detail::shared_count(r);
        boost::detail::sp_enable_shared_from_this( this, tmp, tmp );
    }
 #if !defined( BOOST_NO_SFINAE ) && !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
    template<class Ap>
    explicit shared_ptr( Ap r, typename boost::detail::sp_enable_if_auto_ptr<Ap, int>::type = 0 ): px( r.get() ), pn()
    {
        typename Ap::element_type * tmp = r.get();
        pn = boost::detail::shared_count( r );
        boost::detail::sp_enable_shared_from_this( this, tmp, tmp );
    }
 #endif // BOOST_NO_SFINAE, BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #endif // BOOST_NO_AUTO_PTR
    // assignment
    shared_ptr & operator=( shared_ptr const & r ) // never throws
    {
        this_type(r).swap(*this);
        return *this;
    }
 #if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1400)
    template<class Y>
    shared_ptr & operator=(shared_ptr<Y> const & r) // never throws
    {
        this_type(r).swap(*this);
        return *this;
    }
 #endif
 #ifndef BOOST_NO_AUTO_PTR
    template<class Y>
    shared_ptr & operator=( std::auto_ptr<Y> & r )
    {
        this_type(r).swap(*this);
        return *this;
    }
 #if !defined( BOOST_NO_SFINAE ) && !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
    template<class Ap>
    typename boost::detail::sp_enable_if_auto_ptr< Ap, shared_ptr & >::type operator=( Ap r )
    {
        this_type( r ).swap( *this );
        return *this;
    }
 #endif // BOOST_NO_SFINAE, BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #endif // BOOST_NO_AUTO_PTR
 // Move support
 #if defined( BOOST_HAS_RVALUE_REFS )
    shared_ptr( shared_ptr && r ): px( r.px ), pn() // never throws
    {
        pn.swap( r.pn );
        r.px = 0;
    }
    template<class Y>
 #if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
    shared_ptr( shared_ptr<Y> && r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
 #else
    shared_ptr( shared_ptr<Y> && r )
 #endif
    : px( r.px ), pn() // never throws
    {
        pn.swap( r.pn );
        r.px = 0;
    }
    shared_ptr & operator=( shared_ptr && r ) // never throws
    {
        this_type( std::move( r ) ).swap( *this );
        return *this;
    }
    template<class Y>
    shared_ptr & operator=( shared_ptr<Y> && r ) // never throws
    {
        this_type( std::move( r ) ).swap( *this );
        return *this;
    }
 #endif
    void reset() // never throws in 1.30+
    {
        this_type().swap(*this);
    }
    template<class Y> void reset(Y * p) // Y must be complete
    {
        BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors
        this_type(p).swap(*this);
    }
    template<class Y, class D> void reset( Y * p, D d )
    {
        this_type( p, d ).swap( *this );
    }
    template<class Y, class D, class A> void reset( Y * p, D d, A a )
    {
        this_type( p, d, a ).swap( *this );
    }
    template<class Y> void reset( shared_ptr<Y> const & r, T * p )
    {
        this_type( r, p ).swap( *this );
    }
    reference operator* () const // never throws
    {
        BOOST_ASSERT(px != 0);
        return *px;
    }
    T * operator-> () const // never throws
    {
        BOOST_ASSERT(px != 0);
        return px;
    }
    T * get() const // never throws
    {
        return px;
    }
 // implicit conversion to "bool"
 #include <boost/smart_ptr/detail/operator_bool.hpp>
    bool unique() const // never throws
    {
        return pn.unique();
    }
    long use_count() const // never throws
    {
        return pn.use_count();
    }
    void swap(shared_ptr<T> & other) // never throws
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }
    template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const
    {
        return pn < rhs.pn;
    }
    void * _internal_get_deleter( detail::sp_typeinfo const & ti ) const
    {
        return pn.get_deleter( ti );
    }
    bool _internal_equiv( shared_ptr const & r ) const
    {
        return px == r.px && pn == r.pn;
    }
 // Tasteless as this may seem, making all members public allows member templates
 // to work in the absence of member template friends. (Matthew Langston)
 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 private:
    template<class Y> friend class shared_ptr;
    template<class Y> friend class weak_ptr;
 #endif
    T * px;                     // contained pointer
    boost::detail::shared_count pn;    // reference counter
 };  // shared_ptr
 template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
 {
    return a.get() == b.get();
 }
 template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
 {
    return a.get() != b.get();
 }
 #if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
 // Resolve the ambiguity between our op!= and the one in rel_ops
 template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b)
 {
    return a.get() != b.get();
 }
 #endif
 template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b)
 {
    return a._internal_less(b);
 }
 template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
 {
    a.swap(b);
 }
 template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r)
 {
    return shared_ptr<T>(r, boost::detail::static_cast_tag());
 }
 template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r)
 {
    return shared_ptr<T>(r, boost::detail::const_cast_tag());
 }
 template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r)
 {
    return shared_ptr<T>(r, boost::detail::dynamic_cast_tag());
 }
 // shared_*_cast names are deprecated. Use *_pointer_cast instead.
 template<class T, class U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
 {
    return shared_ptr<T>(r, boost::detail::static_cast_tag());
 }
 template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
 {
    return shared_ptr<T>(r, boost::detail::dynamic_cast_tag());
 }
 template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
 {
    return shared_ptr<T>(r, boost::detail::polymorphic_cast_tag());
 }
 template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
 {
    BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get());
    return shared_static_cast<T>(r);
 }
 // get_pointer() enables boost::mem_fn to recognize shared_ptr
 template<class T> inline T * get_pointer(shared_ptr<T> const & p)
 {
    return p.get();
 }
 // operator<<
 #if !defined(BOOST_NO_IOSTREAM)
 #if defined(BOOST_NO_TEMPLATED_IOSTREAMS) || ( defined(__GNUC__) &&  (__GNUC__ < 3) )
 template<class Y> std::ostream & operator<< (std::ostream & os, shared_ptr<Y> const & p)
 {
    os << p.get();
    return os;
 }
 #else
 // in STLport's no-iostreams mode no iostream symbols can be used
 #ifndef _STLP_NO_IOSTREAMS
 # if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300 && __SGI_STL_PORT)
 // MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL
 using std::basic_ostream;
 template<class E, class T, class Y> basic_ostream<E, T> & operator<< (basic_ostream<E, T> & os, shared_ptr<Y> const & p)
 # else
 template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
 # endif
 {
    os << p.get();
    return os;
 }
 #endif // _STLP_NO_IOSTREAMS
 #endif // __GNUC__ < 3
 #endif // !defined(BOOST_NO_IOSTREAM)
 // get_deleter
 #if ( defined(__GNUC__) && BOOST_WORKAROUND(__GNUC__, < 3) ) || \
    ( defined(__EDG_VERSION__) && BOOST_WORKAROUND(__EDG_VERSION__, <= 238) ) || \
    ( defined(__HP_aCC) && BOOST_WORKAROUND(__HP_aCC, <= 33500) )
 // g++ 2.9x doesn't allow static_cast<X const *>(void *)
 // apparently EDG 2.38 and HP aCC A.03.35 also don't accept it
 template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
 {
    void const * q = p._internal_get_deleter(BOOST_SP_TYPEID(D));
    return const_cast<D *>(static_cast<D const *>(q));
 }
 #else
 template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
 {
    return static_cast<D *>(p._internal_get_deleter(BOOST_SP_TYPEID(D)));
 }
 #endif
 // atomic access
 #if !defined(BOOST_SP_NO_ATOMIC_ACCESS)
 template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * /*p*/ )
 {
    return false;
 }
 template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p )
 {
    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
    return *p;
 }
 template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, memory_order /*mo*/ )
 {
    return atomic_load( p );
 }
 template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r )
 {
    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
    p->swap( r );
 }
 template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order /*mo*/ )
 {
    atomic_store( p, r ); // std::move( r )
 }
 template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r )
 {
    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
    sp.lock();
    p->swap( r );
    sp.unlock();
    return r; // return std::move( r )
 }
 template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order /*mo*/ )
 {
    return atomic_exchange( p, r ); // std::move( r )
 }
 template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
 {
    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
    sp.lock();
    if( p->_internal_equiv( *v ) )
    {
        p->swap( w );
        sp.unlock();
        return true;
    }
    else
    {
        shared_ptr<T> tmp( *p );
        sp.unlock();
        tmp.swap( *v );
        return false;
    }
 }
 template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, memory_order /*success*/, memory_order /*failure*/ )
 {
    return atomic_compare_exchange( p, v, w ); // std::move( w )
 }
 #endif
 } // namespace boost
 #ifdef BOOST_MSVC
 # pragma warning(pop)
 #endif
 #endif  // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
 #endif  // #ifndef BOOST_SMART_PTR_SHARED_PTR_HPP_INCLUDED
--- a/include/boost/smart_ptr/weak_ptr.hpp
+++ b/include/boost/smart_ptr/weak_ptr.hpp
@@ -1,230 +0,0 @@
 #ifndef BOOST_SMART_PTR_WEAK_PTR_HPP_INCLUDED
 #define BOOST_SMART_PTR_WEAK_PTR_HPP_INCLUDED
 //
 //  weak_ptr.hpp
 //
 //  Copyright (c) 2001, 2002, 2003 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)
 //
 //  See http://www.boost.org/libs/smart_ptr/weak_ptr.htm for documentation.
 //
 #include <memory> // boost.TR1 include order fix
 #include <boost/smart_ptr/detail/shared_count.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
 #ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
 # pragma warning(push)
 # pragma warning(disable:4284) // odd return type for operator->
 #endif
 namespace boost
 {
 template<class T> class weak_ptr
 {
 private:
    // Borland 5.5.1 specific workarounds
    typedef weak_ptr<T> this_type;
 public:
    typedef T element_type;
    weak_ptr(): px(0), pn() // never throws in 1.30+
    {
    }
 //  generated copy constructor, assignment, destructor are fine
 //
 //  The "obvious" converting constructor implementation:
 //
 //  template<class Y>
 //  weak_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
 //  {
 //  }
 //
 //  has a serious problem.
 //
 //  r.px may already have been invalidated. The px(r.px)
 //  conversion may require access to *r.px (virtual inheritance).
 //
 //  It is not possible to avoid spurious access violations since
 //  in multithreaded programs r.px may be invalidated at any point.
 //
    template<class Y>
 #if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
    weak_ptr( weak_ptr<Y> const & r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
 #else
    weak_ptr( weak_ptr<Y> const & r )
 #endif
    : px(r.lock().get()), pn(r.pn) // never throws
    {
    }
 #if defined( BOOST_HAS_RVALUE_REFS )
    template<class Y>
 #if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
    weak_ptr( weak_ptr<Y> && r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
 #else
    weak_ptr( weak_ptr<Y> && r )
 #endif
    : px(r.lock().get()), pn(std::move(r.pn)) // never throws
    {
        r.px = 0;
    }
    // for better efficiency in the T == Y case
    weak_ptr( weak_ptr && r ): px( r.px ), pn(std::move(r.pn)) // never throws
    {
        r.px = 0;
    }
    // for better efficiency in the T == Y case
    weak_ptr & operator=( weak_ptr && r ) // never throws
    {
        this_type( std::move( r ) ).swap( *this );
        return *this;
    }
 #endif
    template<class Y>
 #if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
    weak_ptr( shared_ptr<Y> const & r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
 #else
    weak_ptr( shared_ptr<Y> const & r )
 #endif
    : px( r.px ), pn( r.pn ) // never throws
    {
    }
 #if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1300)
    template<class Y>
    weak_ptr & operator=(weak_ptr<Y> const & r) // never throws
    {
        px = r.lock().get();
        pn = r.pn;
        return *this;
    }
 #if defined( BOOST_HAS_RVALUE_REFS )
    template<class Y>
    weak_ptr & operator=(weak_ptr<Y> && r)
    {
        this_type( std::move( r ) ).swap( *this );
        return *this;
    }
 #endif
    template<class Y>
    weak_ptr & operator=(shared_ptr<Y> const & r) // never throws
    {
        px = r.px;
        pn = r.pn;
        return *this;
    }
 #endif
    shared_ptr<T> lock() const // never throws
    {
        return shared_ptr<element_type>( *this, boost::detail::sp_nothrow_tag() );
    }
    long use_count() const // never throws
    {
        return pn.use_count();
    }
    bool expired() const // never throws
    {
        return pn.use_count() == 0;
    }
    bool _empty() const // extension, not in std::weak_ptr
    {
        return pn.empty();
    }
    void reset() // never throws in 1.30+
    {
        this_type().swap(*this);
    }
    void swap(this_type & other) // never throws
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }
    void _internal_assign(T * px2, boost::detail::shared_count const & pn2)
    {
        px = px2;
        pn = pn2;
    }
    template<class Y> bool _internal_less(weak_ptr<Y> const & rhs) const
    {
        return pn < rhs.pn;
    }
 // Tasteless as this may seem, making all members public allows member templates
 // to work in the absence of member template friends. (Matthew Langston)
 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 private:
    template<class Y> friend class weak_ptr;
    template<class Y> friend class shared_ptr;
 #endif
    T * px;                       // contained pointer
    boost::detail::weak_count pn; // reference counter
 };  // weak_ptr
 template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b)
 {
    return a._internal_less(b);
 }
 template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b)
 {
    a.swap(b);
 }
 } // namespace boost
 #ifdef BOOST_MSVC
 # pragma warning(pop)
 #endif    
 #endif  // #ifndef BOOST_SMART_PTR_WEAK_PTR_HPP_INCLUDED
--- a/include/boost/weak_ptr.hpp
+++ b/include/boost/weak_ptr.hpp
@@ -4,15 +4,178 @@
 //
 //  weak_ptr.hpp
 //
-//  Copyright (c) 2001, 2002, 2003 Peter Dimov
+//  Copyright (c) 2001, 2002 Peter Dimov
 //
-//  Distributed under the Boost Software License, Version 1.0.
+//  Permission to copy, use, modify, sell and distribute this software
-//  See accompanying file LICENSE_1_0.txt or copy at
+//  is granted provided this copyright notice appears in all copies.
-//  http://www.boost.org/LICENSE_1_0.txt
+//  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 //  See http://www.boost.org/libs/smart_ptr/weak_ptr.htm for documentation.
 //
-#include <boost/smart_ptr/weak_ptr.hpp>
+#include <boost/shared_ptr.hpp>
 #ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
 # pragma warning(push)
 # pragma warning(disable:4284) // odd return type for operator->
 #endif
 namespace boost
 {
 template<typename T> class weak_ptr
 {
 private:
    // Borland 5.5.1 specific workarounds
    typedef weak_ptr<T> this_type;
 public:
    typedef T element_type;
    weak_ptr(): px(0), pn()
    {
    }
 //  generated copy constructor, assignment, destructor are fine
    template<typename Y>
    weak_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
    {
    }
    template<typename Y>
    weak_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
    {
    }
 #if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
    template<typename Y>
    weak_ptr & operator=(weak_ptr<Y> const & r) // never throws
    {
        px = r.px;
        pn = r.pn;
        return *this;
    }
    template<typename Y>
    weak_ptr & operator=(shared_ptr<Y> const & r) // never throws
    {
        px = r.px;
        pn = r.pn;
        return *this;
    }
 #endif
    void reset()
    {
        this_type().swap(*this);
    }
    T * get() const // never throws; deprecated, removal pending, don't use
    {
        return pn.use_count() == 0? 0: px;
    }
    long use_count() const // never throws
    {
        return pn.use_count();
    }
    bool expired() const // never throws
    {
        return pn.use_count() == 0;
    }
    void swap(this_type & other) // never throws
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }
    bool less(this_type const & rhs) const // implementation detail, never throws
    {
        return pn < rhs.pn;
    }
 // Tasteless as this may seem, making all members public allows member templates
 // to work in the absence of member template friends. (Matthew Langston)
 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 private:
    template<typename Y> friend class weak_ptr;
    template<typename Y> friend class shared_ptr;
 #endif
    T * px;                     // contained pointer
    detail::weak_count pn;      // reference counter
 };  // weak_ptr
 template<class T, class U> inline bool operator==(weak_ptr<T> const & a, weak_ptr<U> const & b)
 {
    return a.get() == b.get();
 }
 template<class T, class U> inline bool operator!=(weak_ptr<T> const & a, weak_ptr<U> const & b)
 {
    return a.get() != b.get();
 }
 #if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
 // Resolve the ambiguity between our op!= and the one in rel_ops
 template<typename T> inline bool operator!=(weak_ptr<T> const & a, weak_ptr<T> const & b)
 {
    return a.get() != b.get();
 }
 #endif
 template<class T> inline bool operator<(weak_ptr<T> const & a, weak_ptr<T> const & b)
 {
    return a.less(b);
 }
 template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b)
 {
    a.swap(b);
 }
 template<class T> shared_ptr<T> make_shared(weak_ptr<T> const & r) // never throws
 {
    // optimization: avoid throw overhead
    if(r.use_count() == 0)
    {
        return shared_ptr<T>();
    }
    try
    {
        return shared_ptr<T>(r);
    }
    catch(use_count_is_zero const &)
    {
        return shared_ptr<T>();
    }
 }
 // Note: there is no get_pointer overload for weak_ptr.
 // This is intentional. Even get() will disappear in a
 // future release; these accessors are too error-prone.
 } // namespace boost
 #ifdef BOOST_MSVC
 # pragma warning(pop)
 #endif    
 #endif  // #ifndef BOOST_WEAK_PTR_HPP_INCLUDED
--- a/index.htm
+++ b/index.htm
@@ -0,0 +1,47 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <title>Boost Smart Pointer Library</title>
 </head>
 <body bgcolor="#FFFFFF" text="#000000">
 <table border="1" bgcolor="#007F7F" cellpadding="2">
  <tr>
    <td bgcolor="#FFFFFF"><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86"></td>
    <td><a href="../../index.htm"><font face="Arial" color="#FFFFFF"><big>Home</big></font></a></td>
    <td><a href="../libraries.htm"><font face="Arial" color="#FFFFFF"><big>Libraries</big></font></a></td>
    <td><a href="../../people/people.htm"><font face="Arial" color="#FFFFFF"><big>People</big></font></a></td>
    <td><a href="../../more/faq.htm"><font face="Arial" color="#FFFFFF"><big>FAQ</big></font></a></td>
    <td><a href="../../more/index.htm"><font face="Arial" color="#FFFFFF"><big>More</big></font></a></td>
  </tr>
 </table>
 <h1>Smart Pointer Library</h1>
 <p>The smart pointer library includes five smart pointer class templates. Smart
 pointers ease the management of memory dynamically allocated with C++ <b>new</b>
 expressions. In addition, <b>scoped_ptr</b> can ease the management of memory
 dynamically allocated in other ways.</p>
 <ul>
  <li><a href="smart_ptr.htm">Documentation</a> (HTML).</li>
  <li>Header <a href="../../boost/scoped_ptr.hpp">scoped_ptr.hpp</a>.</li>
  <li>Header <a href="../../boost/scoped_array.hpp">scoped_array.hpp</a>.</li>
  <li>Header <a href="../../boost/shared_ptr.hpp">shared_ptr.hpp</a>.</li>
  <li>Header <a href="../../boost/shared_array.hpp">shared_array.hpp</a>.</li>
  <li>Header <a href="../../boost/weak_ptr.hpp">weak_ptr.hpp</a>.</li>
  <li>Test program <a href="smart_ptr_test.cpp">smart_ptr_test.cpp</a>.</li>
  <li>Originally submitted by
  	<a href="../../people/greg_colvin.htm">Greg Colvin</a> and
  	<a href="../../people/beman_dawes.html">Beman Dawes</a>,
  	currently maintained by
  	<a href="../../people/peter_dimov.htm">Peter Dimov</a> and
  	<a href="../../people/darin_adler.htm">Darin Adler</a>.</li>
 </ul>
 <p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B %Y" startspan -->1 February 2002<!--webbot bot="Timestamp" endspan i-checksum="14885" -->.</p>
 </body>
 </html>
--- a/index.html
+++ b/index.html
@@ -1,15 +0,0 @@
 <html>
 <head>
 <meta http-equiv="refresh" content="0; URL=smart_ptr.htm">
 </head>
 <body>
 Automatic redirection failed, please go to
 <a href="smart_ptr.htm">smart_ptr.htm</a>.
 </body>
 </html>
 <!--
 	<09> Copyright Beman Dawes, 2001
 	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
 -->
--- a/intrusive_ptr.html
+++ b/intrusive_ptr.html
@@ -1,297 +0,0 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 	<head>
 		<title>intrusive_ptr</title>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
 	<body text="#000000" bgColor="#ffffff">
 		<h1><A href="../../index.htm"><IMG height="86" alt="boost.png (6897 bytes)" src="../../boost.png" width="277" align="middle"
 					border="0"></A>intrusive_ptr class template</h1>
 		<p>
 			<A href="#Introduction">Introduction</A><br>
 			<A href="#Synopsis">Synopsis</A><br>
 			<A href="#Members">Members</A><br>
 			<A href="#functions">Free Functions</A><br>
 		</p>
 		<h2><a name="Introduction">Introduction</a></h2>
 		<p>The <b>intrusive_ptr</b> class template stores a pointer to an object with an 
 			embedded reference count. Every new <b>intrusive_ptr</b> instance increments 
 			the reference count by using an unqualified call to the function <STRONG>intrusive_ptr_add_ref</STRONG>, 
 			passing it the pointer as an argument. Similarly, when an <STRONG>intrusive_ptr</STRONG>
 			is destroyed, it calls <STRONG>intrusive_ptr_release</STRONG>; this function is 
 			responsible for destroying the object when its reference count drops to zero. 
 			The user is expected to provide suitable definitions of these two functions. On 
 			compilers that support argument-dependent lookup, <STRONG>intrusive_ptr_add_ref</STRONG>
 			and <STRONG>intrusive_ptr_release</STRONG> should be defined in the namespace 
 			that corresponds to their parameter; otherwise, the definitions need to go in 
 			namespace <STRONG>boost</STRONG>.</p>
 		<p>The class template is parameterized on <b>T</b>, the type of the object pointed 
 			to. <STRONG>intrusive_ptr&lt;T&gt;</STRONG> can be implicitly converted to <STRONG>intrusive_ptr&lt;U&gt;</STRONG>
 			whenever <STRONG>T*</STRONG> can be implicitly converted to <STRONG>U*</STRONG>.</p>
 		<P>The main reasons to use <STRONG>intrusive_ptr</STRONG> are:</P>
 		<UL>
 			<LI>
 			Some existing frameworks or OSes provide objects with embedded reference 
 			counts;
 			<LI>
 				The memory footprint of <STRONG>intrusive_ptr</STRONG>
 			is the same as the corresponding raw pointer;
 			<LI>
 				<STRONG>intrusive_ptr&lt;T&gt;</STRONG> can be constructed from an arbitrary 
 				raw pointer of type <STRONG>T *</STRONG>.</LI></UL>
 		<P>As a general rule, if it isn't obvious whether <STRONG>intrusive_ptr</STRONG> better 
 			fits your needs than <STRONG>shared_ptr</STRONG>, try a <STRONG>shared_ptr</STRONG>-based 
 			design first.</P>
 		<h2><a name="Synopsis">Synopsis</a></h2>
 		<pre>namespace boost {
  template&lt;class T&gt; class intrusive_ptr {
    public:
      typedef T <A href="#element_type" >element_type</A>;
      <A href="#constructors" >intrusive_ptr</A>(); // never throws
      <A href="#constructors" >intrusive_ptr</A>(T * p, bool add_ref = true);
      <A href="#constructors" >intrusive_ptr</A>(intrusive_ptr const &amp; r);
      template&lt;class Y&gt; <A href="#constructors" >intrusive_ptr</A>(intrusive_ptr&lt;Y&gt; const &amp; r);
      <A href="#destructor" >~intrusive_ptr</A>();
      intrusive_ptr &amp; <A href="#assignment" >operator=</A>(intrusive_ptr const &amp; r);
      template&lt;class Y&gt; intrusive_ptr &amp; <A href="#assignment" >operator=</A>(intrusive_ptr&lt;Y&gt; const &amp; r);
      intrusive_ptr &amp; <A href="#assignment" >operator=</A>(T * r);
      void <a href="#reset" >reset</a>();
      void <a href="#reset" >reset</a>(T * r);
      T &amp; <A href="#indirection" >operator*</A>() const; // never throws
      T * <A href="#indirection" >operator-&gt;</A>() const; // never throws
      T * <A href="#get" >get</A>() const; // never throws
      operator <A href="#conversions" ><i>unspecified-bool-type</i></A>() const; // never throws
      void <A href="#swap" >swap</A>(intrusive_ptr &amp; b); // never throws
  };
  template&lt;class T, class U&gt;
    bool <A href="#comparison" >operator==</A>(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws
  template&lt;class T, class U&gt;
    bool <A href="#comparison" >operator!=</A>(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws
  template&lt;class T&gt;
    bool <A href="#comparison" >operator==</A>(intrusive_ptr&lt;T&gt; const &amp; a, T * b); // never throws
  template&lt;class T&gt;
    bool <A href="#comparison" >operator!=</A>(intrusive_ptr&lt;T&gt; const &amp; a, T * b); // never throws
  template&lt;class T&gt;
    bool <A href="#comparison" >operator==</A>(T * a, intrusive_ptr&lt;T&gt; const &amp; b); // never throws
  template&lt;class T&gt;
    bool <A href="#comparison" >operator!=</A>(T * a, intrusive_ptr&lt;T&gt; const &amp; b); // never throws
  template&lt;class T, class U&gt;
    bool <A href="#comparison" >operator&lt;</A>(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws
  template&lt;class T&gt; void <A href="#free-swap" >swap</A>(intrusive_ptr&lt;T&gt; &amp; a, intrusive_ptr&lt;T&gt; &amp; b); // never throws
  template&lt;class T&gt; T * <A href="#get_pointer" >get_pointer</A>(intrusive_ptr&lt;T&gt; const &amp; p); // never throws
  template&lt;class T, class U&gt;
    intrusive_ptr&lt;T&gt; <A href="#static_pointer_cast" >static_pointer_cast</A>(intrusive_ptr&lt;U&gt; const &amp; r); // never throws
  template&lt;class T, class U&gt;
    intrusive_ptr&lt;T&gt; <A href="#const_pointer_cast" >const_pointer_cast</A>(intrusive_ptr&lt;U&gt; const &amp; r); // never throws
  template&lt;class T, class U&gt;
    intrusive_ptr&lt;T&gt; <A href="#dynamic_pointer_cast" >dynamic_pointer_cast</A>(intrusive_ptr&lt;U&gt; const &amp; r); // never throws
  template&lt;class E, class T, class Y&gt;
    std::basic_ostream&lt;E, T&gt; &amp; <A href="#insertion-operator" >operator&lt;&lt;</A> (std::basic_ostream&lt;E, T&gt; &amp; os, intrusive_ptr&lt;Y&gt; const &amp; p);
 }</pre>
 		<h2><a name="Members">Members</a></h2>
 		<h3><a name="element_type">element_type</a></h3>
 		<pre>typedef T element_type;</pre>
 		<blockquote>
 			<p>Provides the type of the template parameter T.</p>
 		</blockquote>
 		<h3><a name="constructors">constructors</a></h3>
 		<pre>intrusive_ptr(); // never throws</pre>
 		<blockquote>
 			<p><b>Postconditions:</b> <code>get() == 0</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
 		<pre>intrusive_ptr(T * p, bool add_ref = true);</pre>
 		<blockquote>
 			<p><b>Effects:</b> <code>if(p != 0 &amp;&amp; add_ref) intrusive_ptr_add_ref(p);</code>.</p>
 			<p><b>Postconditions:</b> <code>get() == p</code>.</p>
 		</blockquote>
 		<pre>intrusive_ptr(intrusive_ptr const &amp; r);
 template&lt;class Y&gt; intrusive_ptr(intrusive_ptr&lt;Y&gt; const &amp; r);</pre>
 		<blockquote>
 			<p><b>Effects:</b> <code>if(r.get() != 0) intrusive_ptr_add_ref(r.get());</code>.</p>
 			<p><b>Postconditions:</b> <code>get() == r.get()</code>.</p>
 		</blockquote>
 		<h3><a name="destructor">destructor</a></h3>
 		<pre>~intrusive_ptr();</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> <code>if(get() != 0) intrusive_ptr_release(get());</code>.</P>
 		</BLOCKQUOTE>
 		<H3><a name="assignment">assignment</a></H3>
 		<pre>intrusive_ptr &amp; operator=(intrusive_ptr const &amp; r);
 template&lt;class Y&gt; intrusive_ptr &amp; operator=(intrusive_ptr&lt;Y&gt; const &amp; r);
 intrusive_ptr &amp; operator=(T * r);</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>intrusive_ptr(r).swap(*this)</code>.</P>
 			<P><B>Returns:</B> <code>*this</code>.</P>
 		</BLOCKQUOTE>
 		<H3><a name="reset">reset</a></H3>
 		<pre>void reset();</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>intrusive_ptr().swap(*this)</code>.</P>
 		</BLOCKQUOTE>
 		<pre>void reset(T * r);</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>intrusive_ptr(r).swap(*this)</code>.</P>
 		</BLOCKQUOTE>
 		<h3><a name="indirection">indirection</a></h3>
 		<pre>T &amp; operator*() const; // never throws</pre>
 		<blockquote>
 			<p><b>Requirements:</b> <code>get() != 0</code>.</p>
 			<p><b>Returns:</b> <code>*get()</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
 		<pre>T * operator-&gt;() const; // never throws</pre>
 		<blockquote>
 			<p><b>Requirements:</b> <code>get() != 0</code>.</p>
 			<p><b>Returns:</b> <code>get()</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
 		<h3><a name="get">get</a></h3>
 		<pre>T * get() const; // never throws</pre>
 		<blockquote>
 			<p><b>Returns:</b> the stored pointer.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
 		<h3><a name="conversions">conversions</a></h3>
 		<pre>operator <i>unspecified-bool-type</i> () const; // never throws</pre>
 		<blockquote>
 			<p><b>Returns:</b> an unspecified value that, when used in boolean contexts, is 
 				equivalent to <code>get() != 0</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 			<P><B>Notes:</B> This conversion operator allows <b>intrusive_ptr</b> objects to be 
 				used in boolean contexts, like <code>if (p &amp;&amp; p-&gt;valid()) {}</code>. 
 				The actual target type is typically a pointer to a member function, avoiding 
 				many of the implicit conversion pitfalls.</P>
 		</blockquote>
 		<h3><a name="swap">swap</a></h3>
 		<pre>void swap(intrusive_ptr &amp; b); // never throws</pre>
 		<blockquote>
 			<p><b>Effects:</b> Exchanges the contents of the two smart pointers.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
 		<h2><a name="functions">Free Functions</a></h2>
 		<h3><a name="comparison">comparison</a></h3>
 		<pre>template&lt;class T, class U&gt;
  bool operator==(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws</pre>
 		<blockquote>
 			<p><b>Returns:</b> <code>a.get() == b.get()</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
 		<pre>template&lt;class T, class U&gt;
  bool operator!=(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws</pre>
 		<blockquote>
 			<p><b>Returns:</b> <code>a.get() != b.get()</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
 		<pre>template&lt;class T, class U&gt;
  bool operator==(intrusive_ptr&lt;T&gt; const &amp; a, U * b); // never throws</pre>
 		<blockquote>
 			<p><b>Returns:</b> <code>a.get() == b</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
 		<pre>template&lt;class T, class U&gt;
  bool operator!=(intrusive_ptr&lt;T&gt; const &amp; a, U * b); // never throws</pre>
 		<blockquote>
 			<p><b>Returns:</b> <code>a.get() != b</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
 		<pre>template&lt;class T, class U&gt;
  bool operator==(T * a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws</pre>
 		<blockquote>
 			<p><b>Returns:</b> <code>a == b.get()</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
 		<pre>template&lt;class T, class U&gt;
  bool operator!=(T * a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws</pre>
 		<blockquote>
 			<p><b>Returns:</b> <code>a != b.get()</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
 		<pre>template&lt;class T, class U&gt;
  bool operator&lt;(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws</pre>
 		<blockquote>
 			<p><b>Returns:</b> <code>std::less&lt;T *&gt;()(a.get(), b.get())</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 			<P><B>Notes:</B> Allows <STRONG>intrusive_ptr</STRONG> objects to be used as keys 
 				in associative containers.</P>
 		</blockquote>
 		<h3><a name="free-swap">swap</a></h3>
 		<pre>template&lt;class T&gt;
  void swap(intrusive_ptr&lt;T&gt; &amp; a, intrusive_ptr&lt;T&gt; &amp; b); // never throws</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>a.swap(b)</code>.</P>
 			<P><B>Throws:</B> nothing.</P>
 			<P><B>Notes:</B> Matches the interface of <B>std::swap</B>. Provided as an aid to 
 				generic programming.</P>
 		</BLOCKQUOTE>
 		<h3><a name="get_pointer">get_pointer</a></h3>
 		<pre>template&lt;class T&gt;
  T * get_pointer(intrusive_ptr&lt;T&gt; const &amp; p); // never throws</pre>
 		<BLOCKQUOTE>
 			<P><B>Returns:</B> <code>p.get()</code>.</P>
 			<P><B>Throws:</B> nothing.</P>
 			<P><B>Notes:</B> Provided as an aid to generic programming. Used by <A href="../bind/mem_fn.html">
 					mem_fn</A>.</P>
 		</BLOCKQUOTE>
 		<h3><a name="static_pointer_cast">static_pointer_cast</a></h3>
 		<pre>template&lt;class T, class U&gt;
  intrusive_ptr&lt;T&gt; static_pointer_cast(intrusive_ptr&lt;U&gt; const &amp; r); // never throws</pre>
 		<BLOCKQUOTE>
 			<P><B>Returns:</B> <code>intrusive_ptr&lt;T&gt;(static_cast&lt;T*&gt;(r.get()))</code>.</P>
 			<P><B>Throws:</B> nothing.</P>
 		</BLOCKQUOTE>
 		<h3><a name="const_pointer_cast">const_pointer_cast</a></h3>
 		<pre>template&lt;class T, class U&gt;
  intrusive_ptr&lt;T&gt; const_pointer_cast(intrusive_ptr&lt;U&gt; const &amp; r); // never throws</pre>
 		<BLOCKQUOTE>
 			<P><B>Returns:</B> <code>intrusive_ptr&lt;T&gt;(const_cast&lt;T*&gt;(r.get()))</code>.</P>
 			<P><B>Throws:</B> nothing.</P>
 		</BLOCKQUOTE>
 		<h3><a name="dynamic_pointer_cast">dynamic_pointer_cast</a></h3>
 		<pre>template&lt;class T, class U&gt;
  intrusive_ptr&lt;T&gt; dynamic_pointer_cast(intrusive_ptr&lt;U&gt; const &amp; r);</pre>
 		<BLOCKQUOTE>
 			<P><B>Returns:</B> <code>intrusive_ptr&lt;T&gt;(dynamic_cast&lt;T*&gt;(r.get()))</code>.</P>
 			<P><B>Throws:</B> nothing.</P>
 		</BLOCKQUOTE>
 		<h3><a name="insertion-operator">operator&lt;&lt;</a></h3>
 		<pre>template&lt;class E, class T, class Y&gt;
    std::basic_ostream&lt;E, T&gt; &amp; operator&lt;&lt; (std::basic_ostream&lt;E, T&gt; &amp; os, intrusive_ptr&lt;Y&gt; const &amp; p);</pre>
 		<BLOCKQUOTE>
 			<p><STRONG>Effects:</STRONG> <code>os &lt;&lt; p.get();</code>.</p>
 			<P><B>Returns:</B> <code>os</code>.</P>
 		</BLOCKQUOTE>
 		<hr>
 		<p>
 			$Date$</p>
 		<p>
 			<small>Copyright <20> 2003-2005 Peter Dimov. Distributed under the Boost Software License, Version 
 				1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 
 				copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
 	</body>
 </html>
--- a/make_shared.html
+++ b/make_shared.html
@@ -1,119 +0,0 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 	<head>
 		<title>make_shared and allocate_shared</title>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
 	<body text="#000000" bgColor="#ffffff">
 		<h1><A href="../../index.htm"><IMG height="86" alt="boost.png (6897 bytes)" src="../../boost.png" width="277" align="middle"
 					border="0"></A>make_shared and allocate_shared function templates</h1>
 		<p><A href="#Introduction">Introduction</A><br>
 			<A href="#Synopsis">Synopsis</A><br>
 			<A href="#functions">Free Functions</A><br>
 			<A href="#example">Example</A><br>
 		<h2><a name="Introduction">Introduction</a></h2>
 		<p>Consistent use of <a href="shared_ptr.htm"><code>shared_ptr</code></a>
 			can eliminate the need to use an explicit <code>delete</code>,
 			but alone it provides no support in avoiding explicit <code>new</code>.
 			There have been repeated requests from users for a factory function that creates
 			an object of a given type and returns a <code>shared_ptr</code> to it.
 			Besides convenience and style, such a function is also exception safe and
 			considerably faster because it can use a single allocation for both the object
 			and its corresponding control block, eliminating a significant portion of
 			<code>shared_ptr</code>'s construction overhead.
 			This eliminates one of the major efficiency complaints about <code>shared_ptr</code>.
 		</p>
 		<p>The header file &lt;boost/make_shared.hpp&gt; provides a family of overloaded function templates,
 			<code>make_shared</code> and <code>allocate_shared</code>, to address this need.
 			<code>make_shared</code> uses the global operator <code>new</code> to allocate memory,
 			whereas <code>allocate_shared</code> uses an user-supplied allocator, allowing finer control.</p>
 		<p>
 			The rationale for choosing the name <code>make_shared</code> is that the expression
 			<code>make_shared&lt;Widget&gt;()</code> can be read aloud and conveys the intended meaning.</p>
 		<h2><a name="Synopsis">Synopsis</a></h2>
 		<pre>namespace boost {
  template&lt;typename T&gt; class shared_ptr;
  template&lt;typename T&gt;
    shared_ptr&lt;T&gt; <a href="#functions">make_shared</a>();
  template&lt;typename T, typename A&gt;
    shared_ptr&lt;T&gt; <a href="#functions">allocate_shared</a>( A const &amp; );
 #if defined( BOOST_HAS_VARIADIC_TMPL ) && defined( BOOST_HAS_RVALUE_REFS )	// C++0x prototypes
  template&lt;typename T, typename... Args&gt;
    shared_ptr&lt;T&gt; <a href="#functions">make_shared</a>( Args &amp;&amp; ... args );
  template&lt;typename T, typename A, typename... Args&gt;
    shared_ptr&lt;T&gt; <a href="#functions">allocate_shared</a>( A const &amp; a, Args &amp;&amp; ... args );
 #else // no C++0X support
  template&lt;typename T, typename Arg1 &gt;
    shared_ptr&lt;T&gt; <a href="#functions">make_shared</a>( Arg1 const &amp; arg1 );
  template&lt;typename T, typename Arg1, typename Arg2 &gt;
    shared_ptr&lt;T&gt; <a href="#functions">make_shared</a>( Arg1 const &amp; arg1, Arg2 const &amp; arg2 );
 // ...
  template&lt;typename T, typename Arg1, typename Arg2, ..., typename ArgN &gt;
    shared_ptr&lt;T&gt; <a href="#functions">make_shared</a>( Arg1 const &amp; arg1, Arg2 const &amp; arg2, ..., ArgN const &amp; argN );
  template&lt;typename T, typename A, typename Arg1 &gt;
    shared_ptr&lt;T&gt; <a href="#functions">allocate_shared</a>( A const &amp; a, Arg1 const &amp; arg1 );
  template&lt;typename T, typename A, typename Arg1, typename Arg2 &gt;
    shared_ptr&lt;T&gt; <a href="#functions">allocate_shared</a>( Arg1 const &amp; arg1, Arg2 const &amp; arg2 );
 // ...
  template&lt;typename T, typename A, typename Arg1, typename Arg2, ..., typename ArgN &gt;
    shared_ptr&lt;T&gt; <a href="#functions">allocate_shared</a>( A const &amp; a, Arg1 const &amp; arg1, Arg2 const &amp; arg2, ..., ArgN const &amp; argN );
 #endif
 }</pre>
 		<h2><a name="functions">Free Functions</a></h2>
 		<pre>template&lt;class T, class... Args&gt;
    shared_ptr&lt;T&gt; make_shared( Args &amp;&amp; ... args );
 template&lt;class T, class A, class... Args&gt;
    shared_ptr&lt;T&gt; allocate_shared( A const &amp; a, Args &amp;&amp; ... args );</pre>
 		<blockquote>
 			<p><b>Requires:</b> The expression <code>new( pv ) T( std::forward&lt;Args&gt;(args)... )</code>,
 				where <code>pv</code> is a <code>void*</code> pointing to storage suitable
 				to hold an object of type <code>T</code>,
 				shall be well-formed.  <code>A</code> shall be an <em>Allocator</em>,
 				as described in section 20.1.5 (<stong>Allocator requirements</strong>) of the C++ Standard.
 				The copy constructor and destructor of <code>A</code> shall not throw.</p>
 			<p><b>Effects:</b> Allocates memory suitable for an object of type <code>T</code>
 				and constructs an object in it via the placement new expression <code>new( pv ) T()</code>
 				or <code>new( pv ) T( std::forward&lt;Args&gt;(args)... )</code>.
 				<code>allocate_shared</code> uses a copy of <code>a</code> to allocate memory.
 				If an exception is thrown, has no effect.</p>
 			<p><b>Returns:</b> A <code>shared_ptr</code> instance that stores and owns the address
 				of the newly constructed object of type <code>T</code>.</p>
 			<p><b>Postconditions:</b> <code>get() != 0 &amp;&amp; use_count() == 1</code>.</p>
 			<p><b>Throws:</b> <code>bad_alloc</code>, or an exception thrown from <code>A::allocate</code>
 				or the constructor of <code>T</code>.</p>
 			<p><b>Notes:</b> This implementation allocates the memory required for the
 			returned <code>shared_ptr</code> and an object of type <code>T</code> in a single
 			allocation. This provides efficiency equivalent to an intrusive smart pointer.</p>
 			<p>The prototypes shown above are used if your compiler supports rvalue references
 			and variadic templates.  They perfectly forward the <code>args</code> parameters to
 			the constructors of <code>T</code>.</p>
 			<p>Otherwise, the implementation will fall back on
 			forwarding the arguments to the constructors of <code>T</code> as const references.
 			If you need to pass a non-const reference to a constructor of <code>T</code>,
 			you may do so by wrapping the parameter in a call to <code>boost::ref</code>.
 			In addition, you will be
 			limited to a maximum of 9 arguments (not counting the allocator argument of
 			allocate_shared).</p>
 		</blockquote>
 		<h2><a name="example">Example</a></h2>
 		<pre>boost::shared_ptr&lt;std::string&gt; x = boost::make_shared&lt;std::string&gt;("hello, world!");
 std::cout << *x;</pre>
 		<hr>
 		<p>
 			$Date: 2008-05-19 15:42:39 -0400 (Mon, 19 May 2008) $</p>
 		<p><small>Copyright 2008 Peter Dimov. Copyright 2008 Frank Mori Hess.
 				Distributed under the Boost Software License,
 				Version 1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A>
 				or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
 	</body>
 </html>
--- a/pointer_cast.html
+++ b/pointer_cast.html
@@ -1,105 +0,0 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
 <html>
 	<head>
 		<title>pointer_cast.hpp</title>
 	</head>
 	<body>
 		<h1><IMG height="86" alt="C++ Boost" src="../../boost.png" width="277" align="middle" border="0">Pointer 
 			cast functions</h1>
 		<p>The pointer cast functions (<code>boost::static_pointer_cast</code> <code>boost::dynamic_pointer_cast</code>
 			<code>boost::reinterpret_pointer_cast</code> <code>boost::const_pointer_cast</code>) 
 			provide a way to write generic pointer castings for raw pointers. The functions 
 			are defined in <CITE><A href="../../boost/pointer_cast.hpp">boost/pointer_cast.hpp</A>.</CITE></p>
 		<P>There is test/example code in <CITE><A href="test/pointer_cast_test.cpp">pointer_cast_test.cpp</A></CITE>.</p>
 			<h2><a name="rationale">Rationale</a></h2>
 		<P>Boost smart pointers usually overload those functions to provide a mechanism to 
 			emulate pointers casts. For example, <code>boost::shared_ptr&lt;...&gt;</code> implements 
 			a static pointer cast this way:</P>
 		<pre>
 template&lt;class T, class U&gt;
    shared_ptr&lt;T&gt; static_pointer_cast(shared_ptr&lt;U&gt; const &amp;r);
 </pre>
 		<P>Pointer cast functions from <CITE><A href="../../boost/pointer_cast.hpp">boost/pointer_cast.hpp</A></CITE>
 			are overloads of <code>boost::static_pointer_cast</code>, <code>boost::dynamic_pointer_cast</code>,
 			<code>boost::reinterpret_pointer_cast</code> and <code>boost::const_pointer_cast</code>
 			for raw pointers. This way when developing pointer type independent classes, 
 			for example, memory managers or shared memory compatible classes, the same code 
 			can be used for raw and smart pointers.</p>
 			<H2><A name="synopsis">Synopsis</A></H2>
 			<BLOCKQUOTE>
 				<PRE>
 namespace boost {
 template&lt;class T, class U&gt;
 inline T* static_pointer_cast(U *ptr)
  { return static_cast&lt;T*&gt;(ptr); }
 template&lt;class T, class U&gt;
 inline T* dynamic_pointer_cast(U *ptr)
  { return dynamic_cast&lt;T*&gt;(ptr); }
 template&lt;class T, class U&gt;
 inline T* const_pointer_cast(U *ptr)
  { return const_cast&lt;T*&gt;(ptr); }
 template&lt;class T, class U&gt;
 inline T* reinterpret_pointer_cast(U *ptr)
  { return reinterpret_cast&lt;T*&gt;(ptr); }
 } // namespace boost
 </PRE>
 			</BLOCKQUOTE>
 		<P>As you can see from the above synopsis, the pointer cast functions are just 
 			wrappers around standard C++ cast operators.</P>
 		<H2><A name="example">Example</A></H2>
 		<BLOCKQUOTE>
 			<PRE>
 #include &lt;boost/pointer_cast.hpp&gt;
 #include &lt;boost/shared_ptr.hpp&gt;
 class base
 {
 public:
   virtual ~base()
   {
   }
 };
 class derived: public base
 {
 };
 template &lt;class BasePtr&gt;
 void check_if_it_is_derived(const BasePtr &amp;ptr)
 {
   assert(boost::dynamic_pointer_cast&lt;derived&gt;(ptr) != 0);
 }
 int main()
 {
   <I>// Create a raw and a shared_ptr</I>
   base *ptr = new derived;
   boost::shared_ptr&lt;base&gt; sptr(new derived);
   <I>// Check that base pointer points actually to derived class</I>
   check_if_it_is_derived(ptr);
   check_if_it_is_derived(sptr);
   // <EM>Ok!</EM>
   delete ptr;
   return 0;
 }</PRE>
 		</BLOCKQUOTE>
 		<P>The example demonstrates how the generic pointer casts help us create pointer 
 			independent code.</P>
 		<hr>
 		<p>Revised: $Date$</p>
 		<p>Copyright 2005 Ion Gazta<74>aga. Use, modification, and distribution are subject to 
 			the Boost Software License, Version 1.0. (See accompanying file <A href="../../LICENSE_1_0.txt">
 				LICENSE_1_0.txt</A> or a copy at &lt;<A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>&gt;.)</p>
 	</body>
 </html>
--- a/pointer_to_other.html
+++ b/pointer_to_other.html
@@ -1,108 +0,0 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 	<head>
 		<title>pointer_to_other.hpp</title>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
 	<body bgcolor="#ffffff" text="#000000">
 		<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle" WIDTH="277" HEIGHT="86">Header
 			<a href="../../boost/pointer_to_other.hpp">boost/pointer_to_other.hpp</a></h1>
 		<p>
 			The pointer to other utility provides a way, given a source pointer type, 
 			to obtain a pointer of the same type to another pointee type. The utility is 
 			defined in <cite><a href="../../boost/pointer_to_other.hpp">boost/pointer_to_other.hpp</a>.</cite></p>
 		<p>There is test/example code in <cite><a href="test/pointer_to_other_test.cpp">pointer_to_other_test.cpp</a></cite>.</p>
 		<h2><a name="contents">Contents</a></h2>
 		<ul>
 			<li>
 				<a href="#rationale">Rationale</a>
 			<li>
 				<a href="#synopsis">Synopsis</a>
 			<li>
 				<a href="#example">Example</a></li>
 		</ul>
 		<h2><a name="rationale">Rationale</a></h2>
 		<p>When building pointer independent classes, like memory managers, allocators, or 
 			containers, there is often a need to define pointers generically, so that if a 
 			template parameter represents a pointer (for example, a raw or smart pointer to 
 			an int), we can define another pointer of the same type to another pointee (a 
 			raw or smart pointer to a float.)</p>
 		<pre>template &lt;class IntPtr&gt;
 class FloatPointerHolder
 {   
   <em>// Let's define a pointer to a float</em>
   typedef typename boost::pointer_to_other
      &lt;IntPtr, float&gt;::type float_ptr_t;
   float_ptr_t float_ptr;
 };</pre>
 		<h2><a name="synopsis">Synopsis</a></h2>
 		<pre>
 namespace boost {
 template&lt;class T, class U&gt;
   struct pointer_to_other;
 template&lt;class T, class U, template &lt;class&gt; class Sp&gt;
   struct pointer_to_other&lt; Sp&lt;T&gt;, U &gt;
 {
   typedef Sp&lt;U&gt; type;
 };
 template&lt;class T, class T2, class U,
        template &lt;class, class&gt; class Sp&gt;
   struct pointer_to_other&lt; Sp&lt;T, T2&gt;, U &gt;
 {
   typedef Sp&lt;U, T2&gt; type;
 };
 template&lt;class T, class T2, class T3, class U,
        template &lt;class, class, class&gt; class Sp&gt;
 struct pointer_to_other&lt; Sp&lt;T, T2, T3&gt;, U &gt;
 {
   typedef Sp&lt;U, T2, T3&gt; type;
 };
 template&lt;class T, class U&gt;
 struct pointer_to_other&lt; T*, U &gt; 
 {
   typedef U* type;
 };
 } <em>// namespace boost</em></pre>
 		<p>If these definitions are not correct for a specific smart pointer, we can define 
 			a specialization of pointer_to_other.</p>
 		<h2><a name="example">Example</a></h2>
 		<pre><em>// Let's define a memory allocator that can
 // work with raw and smart pointers</em>
 #include &lt;boost/pointer_to_other.hpp&gt;
 template &lt;class VoidPtr&gt;
 class memory_allocator
 {<em>
   // Predefine a memory_block </em>
   struct block;<em>
   // Define a pointer to a memory_block from a void pointer
   // If VoidPtr is void *, block_ptr_t is block*
   // If VoidPtr is smart_ptr&lt;void&gt;, block_ptr_t is smart_ptr&lt;block&gt;</em>
   typedef typename boost::pointer_to_other      
            &lt;VoidPtr, block&gt;::type block_ptr_t;
   struct block
   {
      std::size_t size;
      block_ptr_t next_block;
   };
   block_ptr_t free_blocks;
 };</pre>
 		<p>As we can see, using pointer_to_other we can create pointer independent code.</p>
 		<hr>
 		<p>Last revised: $Date$</p>
 		<p><small>Copyright 2005, 2006 Ion Gazta<74>aga and Peter Dimov. Use, modification, 
 				and distribution are subject to the Boost Software License, Version 1.0.<br>
 				(See accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a 
 				copy at &lt; <a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</small></p>
 	</body>
 </html>
--- a/scoped_array.htm
+++ b/scoped_array.htm
@@ -5,8 +5,8 @@
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
 	<body bgcolor="#ffffff" text="#000000">
-		<h1><A href="../../index.htm"><img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="277" height="86"
+		<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="middle" width="277" height="86"><a name="scoped_array">scoped_array</a>
-					border="0"></A>scoped_array class template</h1>
+			class template</h1>
 		<p>The <b>scoped_array</b> class template stores a pointer to a dynamically 
 			allocated array. (Dynamically allocated arrays are allocated with the C++ <b>new[]</b>
 			expression.) The array pointed to is guaranteed to be deleted, either on 
@@ -14,9 +14,9 @@
 		<p>The <b>scoped_array</b> template is a simple solution for simple needs. It 
 			supplies a basic "resource acquisition is initialization" facility, without 
 			shared-ownership or transfer-of-ownership semantics. Both its name and 
-			enforcement of semantics (by being <a href="../utility/utility.htm#Class_noncopyable">
+			enforcement of semantics (by being <a href="../utility/utility.htm#class noncopyable">
 				noncopyable</a>) signal its intent to retain ownership solely within the 
-			current scope. Because it is <a href="../utility/utility.htm#Class_noncopyable">noncopyable</a>, 
+			current scope. Because it is <a href="../utility/utility.htm#class noncopyable">noncopyable</a>, 
 			it is safer than <b>shared_array</b> for pointers which should not be copied.</p>
 		<p>Because <b>scoped_array</b> is so simple, in its usual implementation every 
 			operation is as fast as a built-in array pointer and it has no more space 
@@ -29,30 +29,28 @@
 			heavier duty but far more flexible. A <b>boost::array</b> is an alternative 
 			that does not use dynamic allocation.</p>
 		<p>The class template is parameterized on <b>T</b>, the type of the object pointed 
-			to. <b>T</b> must meet the smart pointer <a href="smart_ptr.htm#common_requirements">
+			to. <b>T</b> must meet the smart pointer <a href="smart_ptr.htm#Common requirements">
 				common requirements</a>.</p>
 		<h2>Synopsis</h2>
 		<pre>namespace boost {
-  template&lt;class T&gt; class scoped_array : <a href="../utility/utility.htm#Class_noncopyable">noncopyable</a> {
+  template&lt;typename T&gt; class scoped_array : <a href="../utility/utility.htm#noncopyable">noncopyable</a> {
    public:
      typedef T <a href="#element_type">element_type</a>;
      explicit <a href="#ctor">scoped_array</a>(T * p = 0); // never throws
-      <a href="#destructor">~scoped_array</a>(); // never throws
+      <a href="#~scoped_array">~scoped_array</a>(); // never throws
      void <a href="#reset">reset</a>(T * p = 0); // never throws
      T &amp; <a href="#operator[]">operator[]</a>(std::ptrdiff_t i) const; // never throws
      T * <a href="#get">get</a>() const; // never throws
      operator <A href="#conversions" ><i>unspecified-bool-type</i></A>() const; // never throws
      void <a href="#swap">swap</a>(scoped_array &amp; b); // never throws
  };
-  template&lt;class T&gt; void <a href="#free-swap">swap</a>(scoped_array&lt;T&gt; &amp; a, scoped_array&lt;T&gt; &amp; b); // never throws
+  template&lt;typename T&gt; void <a href="#free-swap">swap</a>(scoped_array&lt;T&gt; &amp; a, scoped_array&lt;T&gt; &amp; b); // never throws
 }</pre>
 		<h2>Members</h2>
@@ -64,23 +62,23 @@
 		<pre>explicit scoped_array(T * p = 0); // never throws</pre>
 		<p>Constructs a <b>scoped_array</b>, storing a copy of <b>p</b>, which must have 
 			been allocated via a C++ <b>new</b>[] expression or be 0. <b>T</b> is not 
-			required be a complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">
+			required be a complete type. See the smart pointer <a href="smart_ptr.htm#Common requirements">
 				common requirements</a>.</p>
-		<h3><a name="destructor">destructor</a></h3>
+		<h3><a name="~scoped_array">destructor</a></h3>
 		<pre>~scoped_array(); // never throws</pre>
 		<p>Deletes the array pointed to by the stored pointer. Note that <b>delete[]</b> on 
 			a pointer with a value of 0 is harmless. The guarantee that this does not throw 
 			exceptions depends on the requirement that the deleted array's objects' 
-			destructors do not throw exceptions. See the smart pointer <a href="smart_ptr.htm#common_requirements">
+			destructors do not throw exceptions. See the smart pointer <a href="smart_ptr.htm#Common requirements">
 				common requirements</a>.</p>
 		<h3><a name="reset">reset</a></h3>
 		<pre>void reset(T * p = 0); // never throws</pre>
-		<p>
+		<p>If p is not equal to the stored pointer, deletes the array pointed to by the 
-			Deletes the array pointed to by the stored pointer and then stores a copy of p, 
+			stored pointer and then stores a copy of p, which must have been allocated via 
-			which must have been allocated via a C++ <b>new[]</b> expression or be 0. The 
+			a C++ <b>new[]</b> expression or be 0. The guarantee that this does not throw 
-			guarantee that this does not throw exceptions depends on the requirement that 
+			exceptions depends on the requirement that the deleted array's objects' 
-			the deleted array's objects' destructors do not throw exceptions. See the smart 
+			destructors do not throw exceptions. See the smart pointer <a href="smart_ptr.htm#Common requirements">
-			pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
+				common requirements</a>.</p>
 		<h3><a name="operator[]">subscripting</a></h3>
 		<pre>T &amp; operator[](std::ptrdiff_t i) const; // never throws</pre>
 		<p>Returns a reference to element <b>i</b> of the array pointed to by the stored 
@@ -90,27 +88,24 @@
 		<h3><a name="get">get</a></h3>
 		<pre>T * get() const; // never throws</pre>
 		<p>Returns the stored pointer. <b>T</b> need not be a complete type. See the smart 
-			pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
+			pointer <a href="smart_ptr.htm#Common requirements">common requirements</a>.</p>
 		<h3><a name="conversions">conversions</a></h3>
 		<pre>operator <i>unspecified-bool-type</i> () const; // never throws</pre>
 		<p>Returns an unspecified value that, when used in boolean contexts, is equivalent 
 			to <code>get() != 0</code>.</p>
 		<h3><a name="swap">swap</a></h3>
 		<pre>void swap(scoped_array &amp; b); // never throws</pre>
 		<p>Exchanges the contents of the two smart pointers. <b>T</b> need not be a 
-			complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">common 
+			complete type. See the smart pointer <a href="smart_ptr.htm#Common requirements">common 
 				requirements</a>.</p>
 		<h2><a name="functions">Free Functions</a></h2>
 		<h3><a name="free-swap">swap</a></h3>
-		<pre>template&lt;class T&gt; void swap(scoped_array&lt;T&gt; &amp; a, scoped_array&lt;T&gt; &amp; b); // never throws</pre>
+		<pre>template&lt;typename T&gt; void swap(scoped_array&lt;T&gt; &amp; a, scoped_array&lt;T&gt; &amp; b); // never throws</pre>
 		<p>Equivalent to <b>a.swap(b)</b>. Matches the interface of <b>std::swap</b>. 
 			Provided as an aid to generic programming.</p>
 		<hr>
 		<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan--> 
-			09 January 2003<!--webbot bot="Timestamp" endspan i-checksum="32310"--></p>
+			1 February 2002<!--webbot bot="Timestamp" endspan i-checksum="13964"--></p>
-		<p><small>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
+		<p>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
-			Copyright 2002-2005 Peter Dimov. Distributed under the Boost Software License, Version 
+			Permission to copy, use, modify, sell and distribute this document is granted 
-			1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 
+			provided this copyright notice appears in all copies. This document is provided 
-			copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
+			"as is" without express or implied warranty, and with no claim as to its 
 			suitability for any purpose.</p>
 	</body>
 </html>
--- a/scoped_ptr.htm
+++ b/scoped_ptr.htm
@@ -5,8 +5,8 @@
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
 	<body bgcolor="#ffffff" text="#000000">
-		<h1><A href="../../index.htm"><img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="277" height="86"
+		<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="middle" width="277" height="86"><a name="scoped_ptr">scoped_ptr</a>
-					border="0"></A>scoped_ptr class template</h1>
+			class template</h1>
 		<p>The <b>scoped_ptr</b> class template stores a pointer to a dynamically allocated 
 			object. (Dynamically allocated objects are allocated with the C++ <b>new</b> expression.) 
 			The object pointed to is guaranteed to be deleted, either on destruction of the <b>scoped_ptr</b>, 
@@ -14,9 +14,9 @@
 		<p>The <b>scoped_ptr</b> template is a simple solution for simple needs. It 
 			supplies a basic "resource acquisition is initialization" facility, without 
 			shared-ownership or transfer-of-ownership semantics. Both its name and 
-			enforcement of semantics (by being <a href="../utility/utility.htm#Class_noncopyable">
+			enforcement of semantics (by being <a href="../utility/utility.htm#class noncopyable">
 				noncopyable</a>) signal its intent to retain ownership solely within the 
-			current scope. Because it is <a href="../utility/utility.htm#Class_noncopyable">noncopyable</a>, 
+			current scope. Because it is <a href="../utility/utility.htm#class noncopyable">noncopyable</a>, 
 			it is safer than <b>shared_ptr</b> or <b>std::auto_ptr</b> for pointers which 
 			should not be copied.</p>
 		<p>Because <b>scoped_ptr</b> is simple, in its usual implementation every operation 
@@ -29,12 +29,12 @@
 			allocated array. See <a href="scoped_array.htm"><b>scoped_array</b></a> for 
 			that usage.</p>
 		<p>The class template is parameterized on <b>T</b>, the type of the object pointed 
-			to. <b>T</b> must meet the smart pointer <a href="smart_ptr.htm#common_requirements">
+			to. <b>T</b> must meet the smart pointer <a href="smart_ptr.htm#Common requirements">
 				common requirements</a>.</p>
 		<h2>Synopsis</h2>
 		<pre>namespace boost {
-  template&lt;class T&gt; class scoped_ptr : <a href="../utility/utility.htm#Class_noncopyable">noncopyable</a> {
+  template&lt;typename T&gt; class scoped_ptr : <a href="../utility/utility.htm#class noncopyable">noncopyable</a> {
   public:
     typedef T <a href="#element_type">element_type</a>;
@@ -48,12 +48,10 @@
     T * <a href="#indirection">operator-&gt;</a>() const; // never throws
     T * <a href="#get">get</a>() const; // never throws
     operator <A href="#conversions" ><i>unspecified-bool-type</i></A>() const; // never throws
     void <a href="#swap">swap</a>(scoped_ptr &amp; b); // never throws
  };
-  template&lt;class T&gt; void <a href="#free-swap">swap</a>(scoped_ptr&lt;T&gt; &amp; a, scoped_ptr&lt;T&gt; &amp; b); // never throws
+  template&lt;typename T&gt; void <a href="#free-swap">swap</a>(scoped_ptr&lt;T&gt; &amp; a, scoped_ptr&lt;T&gt; &amp; b); // never throws
 }</pre>
 		<h2>Members</h2>
@@ -64,7 +62,7 @@
 		<pre>explicit scoped_ptr(T * p = 0); // never throws</pre>
 		<p>Constructs a <b>scoped_ptr</b>, storing a copy of <b>p</b>, which must have been 
 			allocated via a C++ <b>new</b> expression or be 0. <b>T</b> is not required be 
-			a complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">common 
+			a complete type. See the smart pointer <a href="smart_ptr.htm#Common requirements">common 
 				requirements</a>.</p>
 		<h3><a name="destructor">destructor</a></h3>
 		<pre>~scoped_ptr(); // never throws</pre>
@@ -73,15 +71,15 @@
 		<P>
 			The guarantee that this does not throw exceptions depends on the requirement 
 			that the deleted object's destructor does not throw exceptions. See the smart 
-			pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</P>
+			pointer <a href="smart_ptr.htm#Common requirements">common requirements</a>.</P>
 		<h3><a name="reset">reset</a></h3>
 		<pre>void reset(T * p = 0); // never throws</pre>
-		<p>
+		<p>If p is not equal to the stored pointer, deletes the object pointed to by the 
-			Deletes the object pointed to by the stored pointer and then stores a copy of 
+			stored pointer and then stores a copy of p, which must have been allocated via 
-			p, which must have been allocated via a C++ <b>new</b> expression or be 0. The 
+			a C++ <b>new</b> expression or be 0. The guarantee that this does not throw 
-			guarantee that this does not throw exceptions depends on the requirement that 
+			exceptions depends on the requirement that the deleted object's destructor does 
-			the deleted object's destructor does not throw exceptions. See the smart 
+			not throw exceptions. See the smart pointer <a href="smart_ptr.htm#Common requirements">
-			pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
+				common requirements</a>.</p>
 		<h3><a name="indirection">indirection</a></h3>
 		<pre>T &amp; operator*() const; // never throws</pre>
 		<p>Returns a reference to the object pointed to by the stored pointer. Behavior is 
@@ -91,19 +89,15 @@
 		<h3><a name="get">get</a></h3>
 		<pre>T * get() const; // never throws</pre>
 		<p>Returns the stored pointer. <b>T</b> need not be a complete type. See the smart 
-			pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
+			pointer <a href="smart_ptr.htm#Common requirements">common requirements</a>.</p>
 		<h3><a name="conversions">conversions</a></h3>
 		<pre>operator <i>unspecified-bool-type</i> () const; // never throws</pre>
 		<p>Returns an unspecified value that, when used in boolean contexts, is equivalent 
 			to <code>get() != 0</code>.</p>
 		<h3><a name="swap">swap</a></h3>
 		<pre>void swap(scoped_ptr &amp; b); // never throws</pre>
 		<p>Exchanges the contents of the two smart pointers. <b>T</b> need not be a 
-			complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">common 
+			complete type. See the smart pointer <a href="smart_ptr.htm#Common requirements">common 
 				requirements</a>.</p>
 		<h2><a name="functions">Free Functions</a></h2>
 		<h3><a name="free-swap">swap</a></h3>
-		<pre>template&lt;class T&gt; void swap(scoped_ptr&lt;T&gt; &amp; a, scoped_ptr&lt;T&gt; &amp; b); // never throws</pre>
+		<pre>template&lt;typename T&gt; void swap(scoped_ptr&lt;T&gt; &amp; a, scoped_ptr&lt;T&gt; &amp; b); // never throws</pre>
 		<p>Equivalent to <b>a.swap(b)</b>. Matches the interface of <b>std::swap</b>. 
 			Provided as an aid to generic programming.</p>
 		<h2><a name="example">Example</a></h2>
@@ -121,7 +115,7 @@ class MyClass {
    int add_one() { return ++*ptr; }
 };
-int main()
+void main()
 {
    boost::scoped_ptr&lt;Shoe&gt; x(new Shoe);
    MyClass my_instance;
@@ -156,12 +150,12 @@ Buckle my shoe</pre>
 		<p>One common usage of <b>scoped_ptr</b> is to implement a handle/body (also called 
 			pimpl) idiom which avoids exposing the body (implementation) in the header 
 			file.</p>
-		<p>The <a href="example/scoped_ptr_example_test.cpp">scoped_ptr_example_test.cpp</a>
+		<p>The <a href="scoped_ptr_example_test.cpp">scoped_ptr_example_test.cpp</a> sample 
-			sample program includes a header file, <a href="example/scoped_ptr_example.hpp">scoped_ptr_example.hpp</a>, 
+			program includes a header file, <a href="scoped_ptr_example.hpp">scoped_ptr_example.hpp</a>, 
 			which uses a <b>scoped_ptr&lt;&gt;</b> to an incomplete type to hide the 
 			implementation. The instantiation of member functions which require a complete 
-			type occurs in the <a href="example/scoped_ptr_example.cpp">scoped_ptr_example.cpp</a>
+			type occurs in the <a href="scoped_ptr_example.cpp">scoped_ptr_example.cpp</a> implementation 
-			implementation file.</p>
+			file.</p>
 		<h2>Frequently Asked Questions</h2>
 		<p><b>Q</b>. Why doesn't <b>scoped_ptr</b> have a release() member?<br>
 			<b>A</b>. When reading source code, it is valuable to be able to draw 
@@ -172,10 +166,11 @@ Buckle my shoe</pre>
 			is required. (supplied by Dave Abrahams)</p>
 		<hr>
 		<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B %Y" startspan -->
-			09 January 2003<!--webbot bot="Timestamp" endspan i-checksum="32310" --></p>
+			17 September 2002<!--webbot bot="Timestamp" endspan i-checksum="15110" --></p>
-		<p><small>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
+		<p>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
-			Copyright 2002-2005 Peter Dimov. Distributed under the Boost Software License, Version 
+			Copyright 2002 Peter Dimov. Permission to copy, use, modify, sell and 
-			1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 
+			distribute this document is granted provided this copyright notice appears in 
-			copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
+			all copies. This document is provided "as is" without express or implied 
 			warranty, and with no claim as to its suitability for any purpose.</p>
 	</body>
 </html>
--- a/example/scoped_ptr_example.cpp
+++ b/example/scoped_ptr_example.cpp
@@ -1,12 +1,5 @@
 // Boost scoped_ptr_example implementation file  -----------------------------//
 //  Copyright Beman Dawes 2001.  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)
 //  See http://www.boost.org/libs/smart_ptr for documentation.
 #include "scoped_ptr_example.hpp"
 #include <iostream>
--- a/example/scoped_ptr_example.hpp
+++ b/example/scoped_ptr_example.hpp
@@ -1,12 +1,5 @@
 //  Boost scoped_ptr_example header file  ------------------------------------//
 //  Copyright Beman Dawes 2001.  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)
 //  See http://www.boost.org/libs/smart_ptr for documentation.
 #include <boost/utility.hpp>
 #include <boost/scoped_ptr.hpp>
--- a/scoped_ptr_example_test.cpp
+++ b/scoped_ptr_example_test.cpp
@@ -0,0 +1,10 @@
 // Boost scoped_ptr_example_test main program  -------------------------------//
 #include "scoped_ptr_example.hpp"
 int main()
 {
  example my_example;
  my_example.do_something();
  return 0;
 }
--- a/shared_array.htm
+++ b/shared_array.htm
@@ -5,8 +5,8 @@
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
 	<body bgcolor="#ffffff" text="#000000">
-		<h1><A href="../../index.htm"><img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="277" height="86"
+		<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="middle" width="277" height="86">shared_array 
-					border="0"></A>shared_array class template</h1>
+			class template</h1>
 		<p>The <b>shared_array</b> class template stores a pointer to a dynamically 
 			allocated array. (Dynamically allocated array are allocated with the C++ <b>new[]</b>
 			expression.) The object pointed to is guaranteed to be deleted when the last <b>shared_array</b>
@@ -26,18 +26,18 @@
 		<p>A <b>shared_ptr</b> to a <b>std::vector</b> is an alternative to a <b>shared_array</b>
 			that is a bit heavier duty but far more flexible.</p>
 		<p>The class template is parameterized on <b>T</b>, the type of the object pointed 
-			to. <b>T</b> must meet the smart pointer <a href="smart_ptr.htm#common_requirements">
+			to. <b>T</b> must meet the smart pointer <a href="smart_ptr.htm#Common requirements">
 				common requirements</a>.</p>
 		<h2>Synopsis</h2>
 		<pre>namespace boost {
-  template&lt;class T&gt; class shared_array {
+  template&lt;typename T&gt; class shared_array {
    public:
      typedef T <a href="#element_type">element_type</a>;
      explicit <a href="#constructors">shared_array</a>(T * p = 0);
-      template&lt;class D&gt; <a href="#constructors">shared_array</a>(T * p, D d);
+      template&lt;typename D&gt; <a href="#constructors">shared_array</a>(T * p, D d);
      <a href="#destructor">~shared_array</a>(); // never throws
      <a href="#constructors">shared_array</a>(shared_array const &amp; r); // never throws
@@ -45,27 +45,25 @@
      shared_array &amp; <a href="#assignment">operator=</a>(shared_array const &amp; r); // never throws
      void <a href="#reset">reset</a>(T * p = 0);
-      template&lt;class D&gt; void <a href="#reset">reset</a>(T * p, D d);
+      template&lt;typename D&gt; void <a href="#reset">reset</a>(T * p, D d);
-      T &amp; <a href="#indexing">operator[]</a>(std::ptrdiff_t i) const; // never throws
+      T &amp; <a href="#indexing">operator[]</a>(std::ptrdiff_t i) const() const; // never throws
      T * <a href="#get">get</a>() const; // never throws
      bool <a href="#unique">unique</a>() const; // never throws
      long <a href="#use_count">use_count</a>() const; // never throws
      operator <A href="#conversions" ><i>unspecified-bool-type</i></A>() const; // never throws
      void <a href="#swap">swap</a>(shared_array&lt;T&gt; &amp; b); // never throws
  };
-  template&lt;class T&gt;
+  template&lt;typename T&gt;
    bool <a href="#comparison">operator==</a>(shared_array&lt;T&gt; const &amp; a, shared_array&lt;T&gt; const &amp; b); // never throws
-  template&lt;class T&gt;
+  template&lt;typename T&gt;
    bool <a href="#comparison">operator!=</a>(shared_array&lt;T&gt; const &amp; a, shared_array&lt;T&gt; const &amp; b); // never throws
-  template&lt;class T&gt;
+  template&lt;typename T&gt;
    bool <a href="#comparison">operator&lt;</a>(shared_array&lt;T&gt; const &amp; a, shared_array&lt;T&gt; const &amp; b); // never throws
-  template&lt;class T&gt; void <a href="#free-swap">swap</a>(shared_array&lt;T&gt; &amp; a, shared_array&lt;T&gt; &amp; b); // never throws
+  template&lt;typename T&gt; void <a href="#free-swap">swap</a>(shared_array&lt;T&gt; &amp; a, shared_array&lt;T&gt; &amp; b); // never throws
 }</pre>
 		<h2>Members</h2>
@@ -80,7 +78,7 @@
 				~shared_array</a>). The only exception which may be thrown by this 
 			constructor is <b>std::bad_alloc</b>. If an exception is thrown, <b>delete[] p</b>
 			is called.</p>
-		<pre>template&lt;class D&gt; shared_array(T * p, D d);</pre>
+		<pre>template&lt;typename D&gt; shared_array(T * p, D d);</pre>
 		<p>Constructs a <b>shared_array</b>, storing a copy of <b>p</b> and of <b>d</b>. 
 			Afterwards, the <a href="#use_count">use count</a> is 1. <b>D</b>'s copy 
 			constructor and destructor must not throw. When the the time comes to delete 
@@ -99,9 +97,9 @@
 			a pointer with a value of 0 is harmless. <b>T</b> need not be a complete type. 
 			The guarantee that this does not throw exceptions depends on the requirement 
 			that the deleted object's destructor does not throw exceptions. See the smart 
-			pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
+			pointer <a href="smart_ptr.htm#Common requirements">common requirements</a>.</p>
-		<h3><a name="assignment">assignment</a></h3>
+		<h3><a name="operator=">assignment</a></h3>
-		<pre>shared_array &amp; operator=(shared_array const &amp; r); // never throws</pre>
+		<pre>shared_array &amp; <a href="#assignment">operator=</a>(shared_array const &amp; r); // never throws</pre>
 		<p>Constructs a new <b>shared_array</b> as described <a href="#constructors">above</a>, 
 			then replaces this <b>shared_array</b> with the new one, destroying the 
 			replaced object.</p>
@@ -111,13 +109,13 @@
 			then replaces this <b>shared_array</b> with the new one, destroying the 
 			replaced object. The only exception which may be thrown is <b>std::bad_alloc</b>. 
 			If an exception is thrown, <b>delete[] p</b> is called.</p>
-		<pre>template&lt;class D&gt; void reset(T * p, D d);</pre>
+		<pre>template&lt;typename D&gt; void reset(T * p, D d);</pre>
 		<p>Constructs a new <b>shared_array</b> as described <a href="#constructors">above</a>, 
 			then replaces this <b>shared_array</b> with the new one, destroying the 
 			replaced object. <b>D</b>'s copy constructor must not throw. The only exception 
 			which may be thrown is <b>std::bad_alloc</b>. If an exception is thrown, <b>d(p)</b>
 			is called.</p>
-		<h3><a name="indexing">indexing</a></h3>
+		<h3><a name="indirection">indexing</a></h3>
 		<pre>T &amp; operator[](std::ptrdiff_t i) const; // never throws</pre>
 		<p>Returns a reference to element <b>i</b> of the array pointed to by the stored 
 			pointer. Behavior is undefined and almost certainly undesirable if the stored 
@@ -126,40 +124,36 @@
 		<h3><a name="get">get</a></h3>
 		<pre>T * get() const; // never throws</pre>
 		<p>Returns the stored pointer. <b>T</b> need not be a complete type. See the smart 
-			pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
+			pointer <a href="smart_ptr.htm#Common requirements">common requirements</a>.</p>
 		<h3><a name="unique">unique</a></h3>
 		<pre>bool unique() const; // never throws</pre>
 		<p>Returns true if no other <b>shared_array</b> is sharing ownership of the stored 
 			pointer, false otherwise. <b>T</b> need not be a complete type. See the smart 
-			pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
+			pointer <a href="smart_ptr.htm#Common requirements">common requirements</a>.</p>
 		<h3><a name="use_count">use_count</a></h3>
 		<pre>long use_count() const; // never throws</pre>
 		<p>Returns the number of <b>shared_array</b> objects sharing ownership of the 
-			stored pointer. <b>T</b> need not be a complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">
+			stored pointer. <b>T</b> need not be a complete type. See the smart pointer <a href="smart_ptr.htm#Common requirements">
 				common requirements</a>.</p>
 		<p>Because <b>use_count</b> is not necessarily efficient to implement for 
 			implementations of <b>shared_array</b> that do not use an explicit reference 
 			count, it might be removed from some future version. Thus it should be used for 
 			debugging purposes only, and not production code.</p>
 		<h3><a name="conversions">conversions</a></h3>
 		<pre>operator <i>unspecified-bool-type</i> () const; // never throws</pre>
 		<p>Returns an unspecified value that, when used in boolean contexts, is equivalent 
 			to <code>get() != 0</code>.</p>
 		<h3><a name="swap">swap</a></h3>
 		<pre>void swap(shared_ptr &amp; b); // never throws</pre>
 		<p>Exchanges the contents of the two smart pointers. <b>T</b> need not be a 
-			complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">common 
+			complete type. See the smart pointer <a href="smart_ptr.htm#Common requirements">common 
 				requirements</a>.</p>
 		<h2><a name="functions">Free Functions</a></h2>
 		<h3><a name="comparison">comparison</a></h3>
-		<pre>template&lt;class T&gt;
+		<pre>template&lt;typename T&gt;
  bool operator==(shared_array&lt;T&gt; const &amp; a, shared_array&lt;T&gt; const &amp; b); // never throws
-template&lt;class T&gt;
+template&lt;typename T&gt;
  bool operator!=(shared_array&lt;T&gt; const &amp; a, shared_array&lt;T&gt; const &amp; b); // never throws
-template&lt;class T&gt;
+template&lt;typename T&gt;
  bool operator&lt;(shared_array&lt;T&gt; const &amp; a, shared_array&lt;T&gt; const &amp; b); // never throws</pre>
 		<p>Compares the stored pointers of the two smart pointers. <b>T</b> need not be a 
-			complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">common 
+			complete type. See the smart pointer <a href="smart_ptr.htm#Common requirements">common 
 				requirements</a>.</p>
 		<p>The <b>operator&lt;</b> overload is provided to define an ordering so that <b>shared_array</b>
 			objects can be used in associative containers such as <b>std::map</b>. The 
@@ -169,17 +163,17 @@ template&lt;class T&gt;
 			paragraph 2) but <b>std::less&lt;&gt;</b> on pointers is well-defined (20.3.3 
 			[lib.comparisons] paragraph 8).</p>
 		<h3><a name="free-swap">swap</a></h3>
-		<pre>template&lt;class T&gt;
+		<pre>template&lt;typename T&gt;
  void swap(shared_array&lt;T&gt; &amp; a, shared_array&lt;T&gt; &amp; b) // never throws</pre>
 		<p>Equivalent to <b>a.swap(b)</b>. Matches the interface of <b>std::swap</b>. 
 			Provided as an aid to generic programming.</p>
 		<hr>
-		<p>Revised 
+		<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan -->
-			<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan --> 
+			8 February 2002<!--webbot bot="Timestamp" i-checksum="38439" endspan --></p>
-			09 January 2003<!--webbot bot="Timestamp" endspan i-checksum="32310" --></p>
+		<p>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
-		<p><small>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
+			Permission to copy, use, modify, sell and distribute this document is granted 
-			Copyright 2002-2005 Peter Dimov. Distributed under the Boost Software License, Version 
+			provided this copyright notice appears in all copies. This document is provided 
-			1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 
+			"as is" without express or implied warranty, and with no claim as to its 
-			copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
+			suitability for any purpose.</p>
 	</body>
 </html>
--- a/shared_ptr.htm
+++ b/shared_ptr.htm
@@ -5,19 +5,18 @@
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
 	<body text="#000000" bgColor="#ffffff">
-		<h1><A href="../../index.htm"><IMG height="86" alt="boost.png (6897 bytes)" src="../../boost.png" width="277" align="middle"
+		<h1><IMG height="86" alt="c++boost.gif (8819 bytes)" src="../../c++boost.gif" width="277" align="middle">shared_ptr 
-					border="0"></A>shared_ptr class template</h1>
+			class template</h1>
 		<p><A href="#Introduction">Introduction</A><br>
-			<A href="#BestPractices">Best Practices</A><br>
+			<a href="#BestPractices">Best Practices</a><br>
 			<A href="#Synopsis">Synopsis</A><br>
 			<A href="#Members">Members</A><br>
 			<A href="#functions">Free Functions</A><br>
 			<A href="#example">Example</A><br>
 			<A href="#Handle/Body">Handle/Body Idiom</A><br>
-			<A href="#ThreadSafety">Thread Safety</A><br>
+			<a href="#ThreadSafety">Thread Safety</a><br>
 			<A href="#FAQ">Frequently Asked Questions</A><br>
-			<A href="smarttests.htm">Smart Pointer Timings</A><br>
+			<A href="smarttests.htm">Smart Pointer Timings</A></p>
 			<A href="sp_techniques.html">Programming Techniques</A></p>
 		<h2><a name="Introduction">Introduction</a></h2>
 		<p>The <b>shared_ptr</b> class template stores a pointer to a dynamically allocated 
 			object, typically with a C++ <EM>new-expression</EM> . The object pointed to is 
@@ -47,16 +46,9 @@
 			to <STRONG>shared_ptr&lt;T const&gt;</STRONG>, to <STRONG>shared_ptr&lt;U&gt;</STRONG>
 			where <STRONG>U</STRONG> is an accessible base of <STRONG>T</STRONG>, and to <STRONG>
 				shared_ptr&lt;void&gt;</STRONG>.</P>
 		<P><STRONG>shared_ptr</STRONG> is now part of <STRONG>TR1</STRONG>, the first C++
 			Library Technical Report. The latest draft of <STRONG>TR1</STRONG> is available
 			at the following location:</P>
 		<P><A href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1745.pdf">http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1745.pdf</A>
 			(1.36Mb PDF)</P>
 		<P>This implementation conforms to the TR1 specification, with the only exception
 			that it resides in namespace <code>boost</code> instead of <code>std::tr1</code>.</P>
 		<h2><a name="BestPractices">Best Practices</a></h2>
-		<P>A simple guideline that nearly eliminates the possibility of memory leaks is:
+		<P>A simple guideline that nearly eliminates the possibility of memory leaks 
-			always use a named smart pointer variable to hold the result of <STRONG>new. </STRONG>
+			is: always use a named smart pointer variable to hold the result of <STRONG>new. </STRONG>
 			Every occurence of the <STRONG>new</STRONG> keyword in the code should have the 
 			form:</P>
 		<PRE>shared_ptr&lt;T&gt; p(new Y);</PRE>
@@ -68,7 +60,8 @@
 			be rare.</P>
 		<P>Avoid using unnamed <STRONG>shared_ptr</STRONG> temporaries to save typing; to 
 			see why this is dangerous, consider this example:</P>
-		<PRE>void f(shared_ptr&lt;int&gt;, int);
+		<PRE>
 void f(shared_ptr&lt;int&gt;, int);
 int g();
 void ok()
@@ -88,47 +81,38 @@ void bad()
 			evaluated in unspecified order, it is possible for <STRONG>new int(2)</STRONG> to 
 			be evaluated first, <STRONG>g()</STRONG> second, and we may never get to the <STRONG>
 				shared_ptr </STRONG>constructor if <STRONG>g</STRONG> throws an exception. 
-			See <A href="http://www.gotw.ca/gotw/056.htm">Herb Sutter's treatment</A> (also <A href="http://www.cuj.com/reference/articles/2002/0212/0212_sutter.htm">
+			See <A href="http://www.gotw.ca/gotw/056.htm">Herb Sutter's treatment</A> of 
-				here</A>) of the issue for more information.</P>
+			the issue for more information.</P>
 		<P>The exception safety problem described above may also be eliminated by using
 			the <a href="make_shared.html"><code>make_shared</code></a>
 			or <a href="make_shared.html"><code>allocate_shared</code></a>
 			factory functions defined in boost/make_shared.hpp.  These factory functions also provide
 			an efficiency benefit by consolidating allocations.<P>
 		<h2><a name="Synopsis">Synopsis</a></h2>
 		<pre>namespace boost {
-  class bad_weak_ptr: public std::exception;
+  class use_count_is_zero: public std::exception;
-  template&lt;class T&gt; class <A href="weak_ptr.htm" >weak_ptr</A>;
+  template&lt;typename T&gt; class <A href="weak_ptr.htm" >weak_ptr</A>;
-  template&lt;class T&gt; class shared_ptr {
+  template&lt;typename T&gt; class shared_ptr {
    public:
      typedef T <A href="#element_type" >element_type</A>;
-      <A href="#constructors" >shared_ptr</A>(); // never throws
+      <A href="#constructors">shared_ptr</A>();
-      template&lt;class Y&gt; explicit <A href="#constructors" >shared_ptr</A>(Y * p);
+      template&lt;typename Y&gt; explicit <A href="#constructors" >shared_ptr</A>(Y * p);
-      template&lt;class Y, class D&gt; <A href="#constructors" >shared_ptr</A>(Y * p, D d);
+      template&lt;typename Y, typename D&gt; <A href="#constructors" >shared_ptr</A>(Y * p, D d);
      template&lt;class Y, class D, class A&gt; <A href="#allocator_constructor" >shared_ptr</A>(Y * p, D d, A a);
      <A href="#destructor">~shared_ptr</A>(); // never throws
      <A href="#constructors">shared_ptr</A>(shared_ptr const &amp; r); // never throws
-      template&lt;class Y&gt; <A href="#constructors" >shared_ptr</A>(shared_ptr&lt;Y&gt; const &amp; r); // never throws
+      template&lt;typename Y&gt; <A href="#constructors">shared_ptr</A>(shared_ptr&lt;Y&gt; const &amp; r); // never throws
-      template&lt;class Y&gt; <A href="#constructors" >shared_ptr</A>(shared_ptr&lt;Y&gt; const &amp; r, T * p); // never throws
+      template&lt;typename Y&gt; explicit <A href="#constructors">shared_ptr</A>(<A href="weak_ptr.htm" >weak_ptr</A>&lt;Y&gt; const &amp; r);
-      template&lt;class Y&gt; explicit <A href="#constructors" >shared_ptr</A>(<A href="weak_ptr.htm" >weak_ptr</A>&lt;Y&gt; const &amp; r);
+      template&lt;typename Y&gt; explicit <A href="#constructors" >shared_ptr</A>(std::auto_ptr&lt;Y&gt; &amp; r);
      template&lt;class Y&gt; explicit <A href="#constructors" >shared_ptr</A>(std::auto_ptr&lt;Y&gt; &amp; r);
      shared_ptr &amp; <A href="#assignment" >operator=</A>(shared_ptr const &amp; r); // never throws  
-      template&lt;class Y&gt; shared_ptr &amp; <A href="#assignment" >operator=</A>(shared_ptr&lt;Y&gt; const &amp; r); // never throws
+      template&lt;typename Y&gt; shared_ptr &amp; <A href="#assignment" >operator=</A>(shared_ptr&lt;Y&gt; const &amp; r); // never throws
-      template&lt;class Y&gt; shared_ptr &amp; <A href="#assignment" >operator=</A>(std::auto_ptr&lt;Y&gt; &amp; r);
+      template&lt;typename Y&gt; shared_ptr &amp; <A href="#assignment" >operator=</A>(std::auto_ptr&lt;Y&gt; &amp; r);
-      void <A href="#reset" >reset</A>(); // never throws
+      void <A href="#reset" >reset</A>();
-      template&lt;class Y&gt; void <A href="#reset" >reset</A>(Y * p);
+      template&lt;typename Y&gt; void <A href="#reset" >reset</A>(Y * p);
-      template&lt;class Y, class D&gt; void <A href="#reset" >reset</A>(Y * p, D d);
+      template&lt;typename Y, typename D&gt; void <A href="#reset" >reset</A>(Y * p, D d);
      template&lt;class Y, class D, class A&gt; void <A href="#reset" >reset</A>(Y * p, D d, A a);
      template&lt;class Y&gt; void <A href="#reset" >reset</A>(shared_ptr&lt;Y&gt; const &amp; r, T * p); // never throws
      T &amp; <A href="#indirection" >operator*</A>() const; // never throws
      T * <A href="#indirection" >operator-&gt;</A>() const; // never throws
@@ -137,39 +121,41 @@ void bad()
      bool <A href="#unique" >unique</A>() const; // never throws
      long <A href="#use_count" >use_count</A>() const; // never throws
-      operator <A href="#conversions" ><i>unspecified-bool-type</i></A>() const; // never throws
+      operator <a href="#conversions"><i>unspecified-bool-type</i></a>() const; // never throws
      void <A href="#swap" >swap</A>(shared_ptr &amp; b); // never throws
  };
-  template&lt;class T, class U&gt;
+  template&lt;typename T, typename U&gt;
    bool <A href="#comparison" >operator==</A>(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b); // never throws
-
+  template&lt;typename T, typename U&gt;
  template&lt;class T, class U&gt;
    bool <A href="#comparison" >operator!=</A>(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b); // never throws
  template&lt;typename T&gt;
    bool <A href="#comparison" >operator&lt;</A>(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;T&gt; const &amp; b); // never throws
-  template&lt;class T, class U&gt;
+  template&lt;typename T&gt; void <A href="#free-swap" >swap</A>(shared_ptr&lt;T&gt; &amp; a, shared_ptr&lt;T&gt; &amp; b); // never throws
    bool <A href="#comparison" >operator&lt;</A>(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b); // never throws
-  template&lt;class T&gt; void <A href="#free-swap" >swap</A>(shared_ptr&lt;T&gt; &amp; a, shared_ptr&lt;T&gt; &amp; b); // never throws
+  template&lt;typename T&gt; T * <A href="#get_pointer" >get_pointer</A>(shared_ptr&lt;T&gt; const &amp; p); // never throws
-  template&lt;class T&gt; T * <A href="#get_pointer" >get_pointer</A>(shared_ptr&lt;T&gt; const &amp; p); // never throws
+  template&lt;typename T, typename U&gt;
    shared_ptr&lt;T&gt; <A href="#shared_static_cast" >shared_static_cast</A>(shared_ptr&lt;U&gt; const &amp; r); // never throws
  template&lt;typename T, typename U&gt;
    shared_ptr&lt;T&gt; <A href="#shared_dynamic_cast" >shared_dynamic_cast</A>(shared_ptr&lt;U&gt; const &amp; r);
  template&lt;typename T, typename U&gt;
    shared_ptr&lt;T&gt; <A href="#shared_polymorphic_cast" >shared_polymorphic_cast</A>(shared_ptr&lt;U&gt; const &amp; r);
  template&lt;typename T, typename U&gt;
    shared_ptr&lt;T&gt; <A href="#shared_polymorphic_downcast" >shared_polymorphic_downcast</A>(shared_ptr&lt;U&gt; const &amp; r); // never throws
  template&lt;class T, class U&gt;
    shared_ptr&lt;T&gt; <A href="#static_pointer_cast" >static_pointer_cast</A>(shared_ptr&lt;U&gt; const &amp; r); // never throws
  template&lt;class T, class U&gt;
    shared_ptr&lt;T&gt; <A href="#const_pointer_cast" >const_pointer_cast</A>(shared_ptr&lt;U&gt; const &amp; r); // never throws
  template&lt;class T, class U&gt;
    shared_ptr&lt;T&gt; <A href="#dynamic_pointer_cast" >dynamic_pointer_cast</A>(shared_ptr&lt;U&gt; const &amp; r); // never throws
  template&lt;class E, class T, class Y&gt;
    std::basic_ostream&lt;E, T&gt; &amp; <A href="#insertion-operator" >operator&lt;&lt;</A> (std::basic_ostream&lt;E, T&gt; &amp; os, shared_ptr&lt;Y&gt; const &amp; p);
  template&lt;class D, class T&gt;
    D * <A href="#get_deleter">get_deleter</A>(shared_ptr&lt;T&gt; const &amp; p);
 }</pre>
 		<P><EM>[It might be convenient to relax the requirements on <STRONG>shared_ptr</STRONG>'s 
 				signature, allowing an additional, defaulted, template parameter; the parameter 
 				can encode the threading model, for example. This would help in detecting 
 				possible ODR violations.</EM></P>
 		<P><EM> On the other hand, using <STRONG>shared_ptr</STRONG> as an argument to a 
 				template template parameter requires an exact signature match. </EM><EM>Metaprogramming 
 				experts tend to deemphasize template template parameters as they are too 
 				inflexible, but the alternative is typically an std::allocator::rebind-type 
 				"hack".]</EM></P>
 		<h2><a name="Members">Members</a></h2>
 		<h3><a name="element_type">element_type</a></h3>
 		<pre>typedef T element_type;</pre>
@@ -177,25 +163,40 @@ void bad()
 			<p>Provides the type of the template parameter T.</p>
 		</blockquote>
 		<h3><a name="constructors">constructors</a></h3>
-		<pre>shared_ptr(); // never throws</pre>
+		<pre>shared_ptr();</pre>
 		<blockquote>
-			<p><b>Effects:</b> Constructs an <EM>empty</EM> <b>shared_ptr</b>.</p>
+			<p><b>Effects:</b> Constructs a <b>shared_ptr</b>.</p>
-			<p><b>Postconditions:</b> <code>use_count() == 0 &amp;&amp; get() == 0</code>.</p>
+			<p><b>Postconditions:</b> <A href="#use_count">use count</A> is 1; the stored 
-			<p><b>Throws:</b> nothing.</p>
+				pointer is 0.</p>
 			<p><b>Throws:</b> <b>std::bad_alloc</b>.</p>
 			<p><b>Exception safety:</b> If an exception is thrown, the constructor has no 
 				effect.</p>
 		</blockquote>
-		<P><EM>[The nothrow guarantee is important, since <STRONG>reset()</STRONG> is specified
+		<P><EM>[The poscondition of use_count() == 1 is too strong. Having the nothrow 
-				in terms of the default constructor; this implies that the constructor must not
+				guarantee is important, since <STRONG>reset()</STRONG> is specified in terms of 
-				allocate memory.]</EM></P>
+				the default constructor, but the current specification requires that a count be 
-		<pre>template&lt;class Y&gt; explicit shared_ptr(Y * p);</pre>
+				allocated. Therefore, this postcondition will be dropped in a future release. 
 				The use count of a default-constructed <STRONG>shared_ptr</STRONG>, including 
 				all copies created from it, will probably be left unspecified.</EM></P>
 		<P><EM>There are two possible nothrow implementations, one stores 0 as a pointer to the 
 				reference count, the other uses a single statically allocated count for all 
 				default-constructed <STRONG>shared_ptr</STRONG>s. The second option is 
 				difficult to achieve in the current header-only reference implementation due to 
 				thread safety issues and initialization order, but it should not be precluded 
 				by the specification.</EM></P>
 		<P><EM>A future release may enable <STRONG>shared_ptr</STRONG> construction from a 
 				literal zero, for consistency with built-in pointers. It is not clear yet 
 				whether this constructor should be left implicit, enabling <STRONG>0</STRONG> to 
 				be used as a shorthand for <STRONG>shared_ptr&lt;T&gt;().</STRONG>]</EM></P>
 		<pre>template&lt;typename Y&gt; explicit shared_ptr(Y * p);</pre>
 		<blockquote>
 			<p><b>Requirements:</b> <b>p</b> must be convertible to <b>T *</b>. <STRONG>Y</STRONG>
 				must be a complete type. The expression <code>delete p</code> must be 
 				well-formed, must not invoke undefined behavior, and must not throw exceptions.
 			</p>
-			<p><b>Effects:</b> Constructs a <b>shared_ptr</b> that <EM>owns</EM> the pointer <b>p</b>.</p>
+			<p><b>Effects:</b> Constructs a <b>shared_ptr</b>, storing a copy of <b>p</b>.</p>
-			<p><b>Postconditions:</b> <code>use_count() == 1 &amp;&amp; get() == p</code>.</p>
+			<p><b>Postconditions:</b> <A href="#use_count">use count</A> is 1.</p>
-			<p><b>Throws:</b> <STRONG>std::bad_alloc</STRONG>, or an implementation-defined
+			<p><b>Throws:</b> <b>std::bad_alloc</b>.</p>
 				exception when a resource other than memory could not be obtained.</p>
 			<p><b>Exception safety:</b> If an exception is thrown, <code>delete p</code> is 
 				called.</p>
 			<P><STRONG>Notes:</STRONG> <B>p</B> must be a pointer to an object that was 
@@ -207,28 +208,38 @@ void bad()
 				pointer type passed. The destructor will call <STRONG>delete</STRONG> with the 
 				same pointer, complete with its original type, even when <STRONG>T</STRONG> does 
 				not have a virtual destructor, or is <STRONG>void</STRONG>.</EM></P>
-		<P><EM>The optional intrusive counting support has been dropped as it exposes too much
+		<P><EM>In the current implementation, if <STRONG>p</STRONG> is convertible to <STRONG>counted_base 
-				implementation details and doesn't interact well with <STRONG>weak_ptr</STRONG>.
+					*</STRONG>, <STRONG>shared_ptr</STRONG> will use the embedded reference 
-				The current implementation uses a different mechanism, <A href="enable_shared_from_this.html">
+				count supplied by <STRONG>counted_base</STRONG>. This is an (experimental) 
-					enable_shared_from_this</A>, to solve the "<STRONG>shared_ptr</STRONG> from <STRONG>
+				attempt to provide a way for <STRONG>shared_ptr</STRONG> to be constructed from 
-					this</STRONG>" problem.</EM><EM>]</EM></P>
+				a raw pointer such as <STRONG>this</STRONG>. A free function <STRONG>shared_from_this(q)</STRONG>
-		<a name="allocator_constructor"></a>
+				performs the conversion when <STRONG>q</STRONG> is convertible to <STRONG>counted_base 
-		<pre>template&lt;class Y, class D&gt; shared_ptr(Y * p, D d);
+					const *</STRONG>.</EM></P>
-template&lt;class Y, class D, class A&gt; shared_ptr(Y * p, D d, A a);</pre>
+		<P><EM>The optional intrusive counting employed by the current implementation allows <STRONG>
 					shared_ptr</STRONG> to interoperate with <STRONG>intrusive_ptr</STRONG>, an 
 				experimental generic intrusive-counted smart pointer.</EM></P>
 		<P><EM> Another possible implementation is to use a global pointer-to-count map instead 
 				of intrusive counting. <STRONG>shared_from_this</STRONG> would no longer be 
 				O(1), which is a concern for some users, although I do not expect any 
 				performance problems, since the operation is rare. Maintaining a global 
 				map is difficult; it needs to be initialized before any <STRONG>shared_ptr</STRONG>
 				instances are constructed, and the initialization needs to be thread safe. 
 				In addition, under the Windows dynamic library model, it is possible for 
 				several maps to exist.</EM></P>
 		<P><EM> It is not yet clear which implementation should be used, or whether the 
 				specification should allow both; nevertheless, the ability to make a <STRONG>shared_ptr</STRONG>
 				from <STRONG>this</STRONG> is considered essential by experienced smart 
 				pointer users.</EM><EM>]</EM></P>
 		<pre>template&lt;typename Y, typename D&gt; shared_ptr(Y * p, D d);</pre>
 		<blockquote>
 			<p><b>Requirements:</b> <B>p</B> must be convertible to <B>T *</B>. <STRONG>D</STRONG>
 				must be <STRONG>CopyConstructible</STRONG>. The copy constructor and destructor 
 				of <b>D</b> must not throw. The expression <code>d(p)</code> must be 
-				well-formed, must not invoke undefined behavior, and must not throw exceptions. <STRONG>
+				well-formed, must not invoke undefined behavior, and must not throw exceptions.
 					A</STRONG> must be an <EM>Allocator</EM>, as described in section 20.1.5 (<STRONG>Allocator
 					requirements</STRONG>) of the C++ Standard.
 			</p>
-			<p><b>Effects:</b> Constructs a <b>shared_ptr</b> that <EM>owns</EM> the pointer <STRONG>
+			<p><b>Effects:</b> Constructs a <b>shared_ptr</b>, storing a copy of <b>p</b> and <b>d</b>.</p>
-					p</STRONG> and the deleter <b>d</b>. The second constructor allocates
+			<p><b>Postconditions:</b> <A href="#use_count">use count</A> is 1.</p>
-				memory using a copy of <STRONG>a</STRONG>.</p>
+			<p><b>Throws:</b> <b>std::bad_alloc</b>.</p>
 			<p><b>Postconditions:</b> <code>use_count() == 1 &amp;&amp; get() == p</code>.</p>
 			<p><b>Throws:</b> <STRONG>std::bad_alloc</STRONG>, or an implementation-defined
 				exception when a resource other than memory could not be obtained.</p>
 			<p><b>Exception safety:</b> If an exception is thrown, <code>d(p)</code> is called.</p>
 			<p><b>Notes:</b> When the the time comes to delete the object pointed to by <b>p</b>, 
 				the stored copy of <STRONG>d</STRONG> is invoked with the stored copy of <STRONG>p</STRONG>
@@ -239,113 +250,112 @@ template&lt;class Y, class D, class A&gt; shared_ptr(Y * p, D d, A a);</pre>
 				is not part of the type, changing the allocation strategy does not break source 
 				or binary compatibility, and does not require a client recompilation. For 
 				example, a "no-op" deallocator is useful when returning a <STRONG>shared_ptr</STRONG>
-				to a statically allocated object, and other variations allow a <STRONG>shared_ptr</STRONG>
+				to a statically allocated object.</EM></P>
 				to be used as a wrapper for another smart pointer, easing interoperability.</EM></P>
 		<P><EM>The support for custom deallocators does not impose significant overhead. Other <STRONG>
 					shared_ptr</STRONG> features still require a deallocator to be kept.</EM></P>
 		<P><EM>The requirement that the copy constructor of <b>D</b> does not throw comes from 
 				the pass by value. If the copy constructor throws, the pointer is leaked. 
-				Removing the requirement requires a pass by (const) reference.</EM></P>
+				Removing the requirement requires a pass by (const) reference. The problems are 
-		<P><EM>The main problem with pass by reference lies in its interaction with rvalues. A
+				that (1) pass by value conveniently changes functions (function references) to 
-				const reference may still cause a copy, and will require a const operator(). A
+				function pointers (this has to be performed manually otherwise and some 
-				non-const reference won't bind to an rvalue at all. A good solution to this
+				compilers may not be able to do it) and (2) const references don't currently 
-				problem is the rvalue reference proposed in <A href="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1377.htm">
+				(per the standard) bind to functions. This can be solved (I think) but it 
-					N1377</A>/<A href="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm">N1385</A>.]</EM></P>
+				requires an overload set that breaks on many compilers due to 14.5.5.2 problems 
 				(and of course it will break on compilers that don't do partial ordering at 
 				all.)</EM></P>
 		<P><EM>The requrement will be removed when the aforementioned issues are 
 				resolved.]</EM></P>
 		<pre>shared_ptr(shared_ptr const &amp; r); // never throws
-template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; const &amp; r); // never throws</pre>
+template&lt;typename Y&gt; shared_ptr(shared_ptr&lt;Y&gt; const &amp; r); // never throws</pre>
 		<blockquote>
-			<p><b>Effects:</b> If <b>r</b> is <EM>empty</EM>, constructs an <EM>empty</EM> <b>shared_ptr</b>;
+			<p><b>Effects:</b> Constructs a <b>shared_ptr</b>, as if by storing a copy of the 
-				otherwise, constructs a <b>shared_ptr</b> that <EM>shares ownership</EM> with <b>r</b>.</p>
+				pointer stored in <STRONG>r</STRONG>.</p>
-			<p><b>Postconditions:</b> <code>get() == r.get() &amp;&amp; use_count() ==
+			<p><b>Postconditions:</b> <A href="#use_count">use count</A> for all copies is 
-					r.use_count()</code>.</p>
+				increased by one.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
-		<pre>template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; const &amp; r, T * p); // never throws</pre>
+		<P><EM>[The postcondition will be relaxed when a default-constructed <STRONG>shared_ptr</STRONG>
 				is being copied.]</EM></P>
 		<pre>template&lt;typename Y&gt; explicit shared_ptr(<A href="weak_ptr.htm">weak_ptr</A>&lt;Y&gt; const &amp; r);</pre>
 		<blockquote>
-			<p><b>Effects:</b> constructs a <b>shared_ptr</b> that <EM>shares ownership</EM> with
+			<p><b>Effects:</b> Constructs a <b>shared_ptr</b>, as if by storing a copy of the 
-				<b>r</b> and stores <b>p</b>.</p>
+				pointer stored in <STRONG>r</STRONG>.</p>
-			<p><b>Postconditions:</b> <code>get() == p &amp;&amp; use_count() == r.use_count()</code>.</p>
+			<p><b>Postconditions:</b> <A href="#use_count">use count</A> for all copies is 
-			<p><b>Throws:</b> nothing.</p>
+				increased by one.</p>
-		</blockquote>
+			<p><b>Throws:</b> <b>use_count_is_zero</b> when <code>r.use_count() == 0</code>.</p>
 		<pre>template&lt;class Y&gt; explicit shared_ptr(<A href="weak_ptr.htm" >weak_ptr</A>&lt;Y&gt; const &amp; r);</pre>
 		<blockquote>
 			<p><b>Effects:</b> Constructs a <b>shared_ptr</b> that <EM>shares ownership</EM> with
 				<b>r</b> and stores a copy of the pointer stored in <STRONG>r</STRONG>.</p>
 			<p><b>Postconditions:</b> <code>use_count() == r.use_count()</code>.</p>
 			<p><b>Throws:</b> <b>bad_weak_ptr</b> when <code>r.use_count() == 0</code>.</p>
 			<p><b>Exception safety:</b> If an exception is thrown, the constructor has no 
 				effect.</p>
 		</blockquote>
-		<pre>template&lt;class Y&gt; shared_ptr(std::auto_ptr&lt;Y&gt; &amp; r);</pre>
+		<P><EM>[This constructor is an optional part of the specification; it depends on the 
 				existence of <STRONG>weak_ptr</STRONG>. It is true that <STRONG>weak_ptr</STRONG>
 				support imposes overhead on every <STRONG>shared_ptr</STRONG> user, regardless 
 				of whether weak pointers are used.</EM></P>
 		<P><EM>On the other hand, cyclic references are a serious problem with all reference 
 				counted designs. Not providing a solution within the library is unacceptable; 
 				if users are forced to reinvent the weak pointer wheel, there is substantial 
 				probability that they will get it wrong, as designing a safe <STRONG>weak_ptr</STRONG>
 				interface is non-trivial.</EM></P>
 		<P><EM>My opinion is that the added functionality is worth the cost. <STRONG>weak_ptr</STRONG>
 				is provided in the reference implementation as a proof of concept.]</EM></P>
 		<pre>template&lt;typename Y&gt; shared_ptr(std::auto_ptr&lt;Y&gt; &amp; r);</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Constructs a <B>shared_ptr</B>, as if by storing a copy of <STRONG>r.release()</STRONG>.</P>
-			<p><b>Postconditions:</b> <code>use_count() == 1</code>.</p>
+			<P><B>Postconditions:</B> <A href="#use_count">use count</A> is 1.</P>
-			<p><b>Throws:</b> <STRONG>std::bad_alloc</STRONG>, or an implementation-defined
+			<P><B>Throws:</B> <B>std::bad_alloc</B>.</P>
 				exception when a resource other than memory could not be obtained.</p>
 			<P><B>Exception safety:</B> If an exception is thrown, the constructor has no 
 				effect.</P>
 		</BLOCKQUOTE>
 		<P><EM>[This constructor takes a the source <STRONG>auto_ptr</STRONG> by reference and 
 				not by value, and cannot accept <STRONG>auto_ptr</STRONG> temporaries. This is 
-				by design, as the constructor offers the strong guarantee; an rvalue reference
+				by design, as the constructor offers the strong guarantee.]</EM></P>
 				would solve this problem, too.]</EM></P>
 		<h3><a name="destructor">destructor</a></h3>
 		<pre>~shared_ptr(); // never throws</pre>
 		<BLOCKQUOTE>
-			<P><B>Effects:</B></P>
+			<P><B>Effects:</B> If <STRONG>*this</STRONG> is the sole owner (<code>use_count() == 1</code>), 
-			<UL>
+				destroys the object pointed to by the stored pointer.</P>
-				<LI>
+			<P><B>Postconditions:</B> <A href="#use_count">use count</A> for all remaining 
-					If <STRONG>*this</STRONG> is <EM>empty</EM>, or <EM>shares ownership</EM> with
+				copies is decreased by one.</P>
 					another <STRONG>shared_ptr</STRONG> instance (<code>use_count() &gt; 1</code>),
 				there are no side effects.
 				<LI>
 					Otherwise, if <STRONG>*this</STRONG> <EM>owns</EM> a pointer <STRONG>p</STRONG>
 					and a deleter <STRONG>d</STRONG>, <code>d(p)</code>
 				is called.
 				<LI>
 					Otherwise, <STRONG>*this</STRONG> <EM>owns</EM> a pointer <STRONG>p</STRONG>,
 					and <code>delete p</code> is called.</LI></UL>
 			<P><B>Throws:</B> nothing.</P>
 		</BLOCKQUOTE>
 		<H3><a name="assignment">assignment</a></H3>
 		<pre>shared_ptr &amp; operator=(shared_ptr const &amp; r); // never throws
-template&lt;class Y&gt; shared_ptr &amp; operator=(shared_ptr&lt;Y&gt; const &amp; r); // never throws
+template&lt;typename Y&gt; shared_ptr &amp; operator=(shared_ptr&lt;Y&gt; const &amp; r); // never throws
-template&lt;class Y&gt; shared_ptr &amp; operator=(std::auto_ptr&lt;Y&gt; &amp; r);</pre>
+template&lt;typename Y&gt; shared_ptr &amp; operator=(std::auto_ptr&lt;Y&gt; &amp; r);</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>shared_ptr(r).swap(*this)</code>.</P>
 			<P><B>Returns:</B> <code>*this</code>.</P>
 			<P><B>Notes:</B> The use count updates caused by the temporary object construction 
 				and destruction are not considered observable side effects, and the 
 				implementation is free to meet the effects (and the implied guarantees) via 
 				different means, without creating a temporary. In particular, in the example:</P>
-			<pre>shared_ptr&lt;int&gt; p(new int);
+			<pre>
 shared_ptr&lt;int&gt; p(new int);
 shared_ptr&lt;void&gt; q(p);
 p = p;
 q = p;
 </pre>
 			<p>both assignments may be no-ops.</p>
 		</BLOCKQUOTE>
 		<P><EM>[Some experts consider the note to be redundant, as it appears to essentially 
 				mirror the "as if" rile. However, experience suggests that when C++ code is 
 				used to describe effects, it is often misinterpreted as required 
 				implementation. In addition, it is not entirely clear whether the "as if" rule 
 				actually applies here, so it's better to be explicit about the possible 
 				optimizations.]</EM></P>
 		<h3><a name="reset">reset</a></h3>
-		<pre>void reset(); // never throws</pre>
+		<pre>void reset();</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>shared_ptr().swap(*this)</code>.</P>
 		</BLOCKQUOTE>
-		<pre>template&lt;class Y&gt; void reset(Y * p);</pre>
+		<P><EM>[<STRONG>reset()</STRONG> will offer the nothrow guarantee in a future 
 				implementation.]</EM></P>
 		<pre>template&lt;typename Y&gt; void reset(Y * p);</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>shared_ptr(p).swap(*this)</code>.</P>
 		</BLOCKQUOTE>
-		<pre>template&lt;class Y, class D&gt; void reset(Y * p, D d);</pre>
+		<pre>template&lt;typename Y, typename D&gt; void reset(Y * p, D d);</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>shared_ptr(p, d).swap(*this)</code>.</P>
 		</BLOCKQUOTE>
 		<pre>template&lt;class Y, class D, class A&gt; void reset(Y * p, D d, A a);</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>shared_ptr(p, d, a).swap(*this)</code>.</P>
 		</BLOCKQUOTE>
 		<pre>template&lt;class Y&gt; void reset(shared_ptr&lt;Y&gt; const &amp; r, T * p); // never throws</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>shared_ptr(r, p).swap(*this)</code>.</P>
 		</BLOCKQUOTE>
 		<h3><a name="indirection">indirection</a></h3>
 		<pre>T &amp; operator*() const; // never throws</pre>
 		<blockquote>
@@ -374,12 +384,13 @@ q = p;
 				If you are using <code>unique()</code> to implement copy on write, do not rely 
 				on a specific value when the stored pointer is zero.</P>
 		</blockquote>
 		<P><EM>[In a future release, <STRONG>unique()</STRONG> will return an unspecified value 
 				for a default-constructed <STRONG>shared_ptr.</STRONG>]</EM></P>
 		<h3><a name="use_count">use_count</a></h3>
 		<pre>long use_count() const; // never throws</pre>
 		<blockquote>
-			<p><b>Returns:</b> the number of <b>shared_ptr</b> objects, <STRONG>*this</STRONG> included,
+			<p><b>Returns:</b> the number of <b>shared_ptr</b> objects sharing ownership of the 
-				that <i>share ownership</i> with <b>*this</b>, or 0 when <STRONG>*this</STRONG>
+				stored pointer.</p>
 				is <EM>empty</EM>.</p>
 			<p><b>Throws:</b> nothing.</p>
 			<P><B>Notes:</B> <code>use_count()</code> is not necessarily efficient. Use only 
 				for debugging and testing purposes, not for production code.</P>
@@ -387,8 +398,8 @@ q = p;
 		<h3><a name="conversions">conversions</a></h3>
 		<pre>operator <i>unspecified-bool-type</i> () const; // never throws</pre>
 		<blockquote>
-			<p><b>Returns:</b> an unspecified value that, when used in boolean contexts, is
+			<p><b>Returns:</b> an unspecified value that, when used in boolean contexts, 
-				equivalent to <code>get() != 0</code>.</p>
+				is equivalent to <code>get() != 0</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 			<P><B>Notes:</B> This conversion operator allows <b>shared_ptr</b> objects to be 
 				used in boolean contexts, like <code>if (p &amp;&amp; p-&gt;valid()) {}</code>. 
@@ -396,8 +407,8 @@ q = p;
 				many of the implicit conversion pitfalls.</P>
 		</blockquote>
 		<P><EM>[The conversion to bool is not merely syntactic sugar. It allows <STRONG>shared_ptr</STRONG>s 
-				to be declared in conditions when using <A href="#dynamic_pointer_cast">dynamic_pointer_cast</A>
+				to be declared in conditions when using <STRONG>shared_dynamic_cast </STRONG>or <STRONG>
-				or <A href="weak_ptr.htm#lock">weak_ptr::lock</A>.]</EM></P>
+					make_shared</STRONG>.]</EM></P>
 		<h3><a name="swap">swap</a></h3>
 		<pre>void swap(shared_ptr &amp; b); // never throws</pre>
 		<blockquote>
@@ -406,30 +417,24 @@ q = p;
 		</blockquote>
 		<h2><a name="functions">Free Functions</a></h2>
 		<h3><a name="comparison">comparison</a></h3>
-		<pre>template&lt;class T, class U&gt;
+		<pre>template&lt;typename T, typename U&gt;
  bool operator==(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b); // never throws</pre>
 		<blockquote>
 			<p><b>Returns:</b> <code>a.get() == b.get()</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
-		<pre>template&lt;class T, class U&gt;
+		<pre>template&lt;typename T, typename U&gt;
  bool operator!=(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b); // never throws</pre>
 		<blockquote>
 			<p><b>Returns:</b> <code>a.get() != b.get()</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
-		<pre>template&lt;class T, class U&gt;
+		<pre>template&lt;typename T&gt;
-  bool operator&lt;(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b); // never throws</pre>
+  bool operator&lt;(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;T&gt; const &amp; b); // never throws</pre>
 		<blockquote>
-			<p><b>Returns:</b> an unspecified value such that</p>
+			<p><b>Returns:</b> an unspecified value such that <b>operator&lt;</b> is a 
-			<UL>
+				strict weak ordering as described in section 25.3 <code>[lib.alg.sorting]</code>
-				<LI>
+				of the C++ standard.</p>
 					<b>operator&lt;</b> is a strict weak ordering as described in section 25.3 <code>[lib.alg.sorting]</code>
 				of the C++ standard;
 				<LI>
 					under the equivalence relation defined by <STRONG>operator&lt;</STRONG>, <code>!(a
 						&lt; b) &amp;&amp; !(b &lt; a)</code>, two <STRONG>shared_ptr</STRONG> instances
 					are equivalent if and only if they <EM>share ownership</EM> or are both <EM>empty</EM>.</LI></UL>
 			<p><b>Throws:</b> nothing.</p>
 			<P><B>Notes:</B> Allows <STRONG>shared_ptr</STRONG> objects to be used as keys in 
 				associative containers.</P>
@@ -443,7 +448,7 @@ q = p;
 				subobjects' <STRONG>operator&lt;</STRONG>.</EM></P>
 		<P><EM>The rest of the comparison operators are omitted by design.]</EM></P>
 		<h3><a name="free-swap">swap</a></h3>
-		<pre>template&lt;class T&gt;
+		<pre>template&lt;typename T&gt;
  void swap(shared_ptr&lt;T&gt; &amp; a, shared_ptr&lt;T&gt; &amp; b); // never throws</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>a.swap(b)</code>.</P>
@@ -455,7 +460,7 @@ q = p;
 				as this is currently the only legal way to supply a <STRONG>swap</STRONG> function 
 				that has a chance to be used by the standard library.]</EM></P>
 		<h3><a name="get_pointer">get_pointer</a></h3>
-		<pre>template&lt;class T&gt;
+		<pre>template&lt;typename T&gt;
  T * get_pointer(shared_ptr&lt;T&gt; const &amp; p); // never throws</pre>
 		<BLOCKQUOTE>
 			<P><B>Returns:</B> <code>p.get()</code>.</P>
@@ -463,39 +468,23 @@ q = p;
 			<P><B>Notes:</B> Provided as an aid to generic programming. Used by <A href="../bind/mem_fn.html">
 					mem_fn</A>.</P>
 		</BLOCKQUOTE>
-		<h3><a name="static_pointer_cast">static_pointer_cast</a></h3>
+		<h3><a name="shared_static_cast">shared_static_cast</a></h3>
-		<pre>template&lt;class T, class U&gt;
+		<pre>template&lt;typename T, typename U&gt;
-  shared_ptr&lt;T&gt; static_pointer_cast(shared_ptr&lt;U&gt; const &amp; r); // never throws</pre>
+  shared_ptr&lt;T&gt; shared_static_cast(shared_ptr&lt;U&gt; const &amp; r); // never throws</pre>
 		<BLOCKQUOTE>
 			<P><STRONG>Requires:</STRONG> The expression <code>static_cast&lt;T*&gt;(r.get())</code>
 				must be well-formed.</P>
-			<P><B>Returns:</B> If <b>r</b> is <i>empty</i>, an <i>empty</i> <b>shared_ptr&lt;T&gt;</b>;
+			<P><B>Returns:</B> A <STRONG>shared_ptr&lt;T&gt;</STRONG> object that stores a copy 
-				otherwise, a <STRONG>shared_ptr&lt;T&gt;</STRONG> object that stores a copy of <code>
+				of <code>static_cast&lt;T*&gt;(r.get())</code> and shares ownership with <b>r</b>.</P>
 					static_cast&lt;T*&gt;(r.get())</code> and <i>shares ownership</i> with <b>r</b>.</P>
 			<P><B>Throws:</B> nothing.</P>
 			<P><B>Notes:</B> the seemingly equivalent expression</P>
 			<p><code>shared_ptr&lt;T&gt;(static_cast&lt;T*&gt;(r.get()))</code></p>
 			<p>will eventually result in undefined behavior, attempting to delete the same 
 				object twice.</p>
 		</BLOCKQUOTE>
-		<h3><a name="const_pointer_cast">const_pointer_cast</a></h3>
+		<h3><a name="shared_dynamic_cast">shared_dynamic_cast</a></h3>
-		<pre>template&lt;class T, class U&gt;
+		<pre>template&lt;typename T, typename U&gt;
-  shared_ptr&lt;T&gt; const_pointer_cast(shared_ptr&lt;U&gt; const &amp; r); // never throws</pre>
+  shared_ptr&lt;T&gt; shared_dynamic_cast(shared_ptr&lt;U&gt; const &amp; r);</pre>
 		<BLOCKQUOTE>
 			<P><STRONG>Requires:</STRONG> The expression <code>const_cast&lt;T*&gt;(r.get())</code>
 				must be well-formed.</P>
 			<P><B>Returns:</B> If <b>r</b> is <i>empty</i>, an <i>empty</i> <b>shared_ptr&lt;T&gt;</b>;
 				otherwise, a <STRONG>shared_ptr&lt;T&gt;</STRONG> object that stores a copy of <code>
 					const_cast&lt;T*&gt;(r.get())</code> and <i>shares ownership</i> with <b>r</b>.</P>
 			<P><B>Throws:</B> nothing.</P>
 			<P><B>Notes:</B> the seemingly equivalent expression</P>
 			<p><code>shared_ptr&lt;T&gt;(const_cast&lt;T*&gt;(r.get()))</code></p>
 			<p>will eventually result in undefined behavior, attempting to delete the same
 				object twice.</p>
 		</BLOCKQUOTE>
 		<h3><a name="dynamic_pointer_cast">dynamic_pointer_cast</a></h3>
 		<pre>template&lt;class T, class U&gt;
  shared_ptr&lt;T&gt; dynamic_pointer_cast(shared_ptr&lt;U&gt; const &amp; r);</pre>
 		<BLOCKQUOTE>
 			<P><STRONG>Requires:</STRONG> The expression <CODE>dynamic_cast&lt;T*&gt;(r.get())</CODE>
 				must be well-formed and its behavior defined.</P>
@@ -503,36 +492,47 @@ q = p;
 			<UL>
 				<LI>
 					When <CODE>dynamic_cast&lt;T*&gt;(r.get())</CODE> returns a nonzero value, a <STRONG>
-						shared_ptr&lt;T&gt;</STRONG> object that stores a copy of it and <i>shares
+						shared_ptr&lt;T&gt;</STRONG> object that stores a copy of it and shares 
-						ownership</i> with <STRONG>r</STRONG>;
+					ownership with <STRONG>r</STRONG>;
 				<LI>
-					Otherwise, an <i>empty</i> <STRONG>shared_ptr&lt;T&gt;</STRONG> object.</LI></UL>
+					Otherwise, a default-constructed <STRONG>shared_ptr&lt;T&gt;</STRONG> object.</LI></UL>
-			<P><B>Throws:</B> nothing.</P>
+			<P><B>Throws:</B> <STRONG>std::bad_alloc</STRONG>.</P>
 			<P><B>Exception safety:</B> If an exception is thrown, the function has no effect.</P>
 			<P><B>Notes:</B> the seemingly equivalent expression</P>
 			<P><CODE>shared_ptr&lt;T&gt;(dynamic_cast&lt;T*&gt;(r.get()))</CODE></P>
 			<P>will eventually result in undefined behavior, attempting to delete the same 
 				object twice.</P>
 		</BLOCKQUOTE>
-		<h3><a name="insertion-operator">operator&lt;&lt;</a></h3>
+		<h3><a name="shared_polymorphic_cast">shared_polymorphic_cast</a></h3>
-		<pre>template&lt;class E, class T, class Y&gt;
+		<pre>template&lt;typename T, typename U&gt;
-    std::basic_ostream&lt;E, T&gt; &amp; operator&lt;&lt; (std::basic_ostream&lt;E, T&gt; &amp; os, shared_ptr&lt;Y&gt; const &amp; p);</pre>
+  shared_ptr&lt;T&gt; shared_polymorphic_cast(shared_ptr&lt;U&gt; const &amp; r);</pre>
 		<BLOCKQUOTE>
-			<p><STRONG>Effects:</STRONG> <code>os &lt;&lt; p.get();</code>.</p>
+			<p><STRONG>Requires:</STRONG> The expression <CODE><A href="../conversion/cast.htm#Polymorphic_cast">
-			<P><B>Returns:</B> <b>os</b>.</P>
+						polymorphic_cast</A>&lt;T*&gt;(r.get())</CODE> must be well-formed and 
 				its behavior defined.</p>
 			<P><B>Returns:</B> A <STRONG>shared_ptr&lt;T&gt;</STRONG> object that stores a copy 
 				of <CODE><A href="../conversion/cast.htm#Polymorphic_cast">polymorphic_cast</A>&lt;T*&gt;(r.get())</CODE>
 				and shares ownership with <B>r</B>.</P>
 			<P><B>Throws:</B> <STRONG>std::bad_cast</STRONG> when the pointer cannot be 
 				converted.</P>
 			<P><B>Exception safety:</B> If an exception is thrown, the function has no effect.</P>
 		</BLOCKQUOTE>
-		<h3><a name="get_deleter">get_deleter</a></h3>
+		<h3><a name="shared_polymorphic_downcast">shared_polymorphic_downcast</a></h3>
-		<pre>template&lt;class D, class T&gt;
+		<pre>template&lt;typename T, typename U&gt;
-    D * get_deleter(shared_ptr&lt;T&gt; const &amp; p);</pre>
+  shared_ptr&lt;T&gt; shared_polymorphic_downcast(shared_ptr&lt;U&gt; const &amp; r); // never throws</pre>
 		<BLOCKQUOTE>
-			<P><B>Returns:</B> If <STRONG>*this</STRONG> <EM>owns</EM> a deleter <STRONG>d</STRONG>
+			<p><STRONG>Requires:</STRONG> The expression <CODE><A href="../conversion/cast.htm#Polymorphic_cast">
-				of type (cv-unqualified) <STRONG>D</STRONG>, returns <code>&amp;d</code>;
+						polymorphic_downcast</A>&lt;T*&gt;(r.get())</CODE> must be well-formed 
-				otherwise returns 0.</P>
+				and its behavior defined.</p>
 			<P><B>Returns:</B> A <STRONG>shared_ptr&lt;T&gt;</STRONG> object that stores a copy 
 				of <CODE><A href="../conversion/cast.htm#Polymorphic_cast">polymorphic_downcast</A>&lt;T*&gt;(r.get())</CODE>
 				and shares ownership with <B>r</B>.</P>
 			<P><B>Throws:</B> nothing.</P>
 		</BLOCKQUOTE>
 		<h2><a name="example">Example</a></h2>
-		<p>See <A href="example/shared_ptr_example.cpp">shared_ptr_example.cpp</A> for a
+		<p>See <A href="shared_ptr_example.cpp">shared_ptr_example.cpp</A> for a complete 
-			complete example program. The program builds a <b>std::vector</b> and <b>std::set</b>
+			example program. The program builds a <b>std::vector</b> and <b>std::set</b> of <b>shared_ptr</b>
-			of <b>shared_ptr</b> objects.</p>
+			objects.</p>
 		<p>Note that after the containers have been populated, some of the <b>shared_ptr</b>
 			objects will have a use count of 1 rather than a use count of 2, since the set 
 			is a <b>std::set</b> rather than a <b>std::multiset</b>, and thus does not 
@@ -545,25 +545,26 @@ q = p;
 		<p>One common usage of <b>shared_ptr</b> is to implement a handle/body (also called 
 			pimpl) idiom which avoids exposing the body (implementation) in the header 
 			file.</p>
-		<p>The <A href="example/shared_ptr_example2_test.cpp">shared_ptr_example2_test.cpp</A>
+		<p>The <A href="shared_ptr_example2_test.cpp">shared_ptr_example2_test.cpp</A> sample 
-			sample program includes a header file, <A href="example/shared_ptr_example2.hpp">shared_ptr_example2.hpp</A>,
+			program includes a header file, <A href="shared_ptr_example2.hpp">shared_ptr_example2.hpp</A>, 
 			which uses a <b>shared_ptr&lt;&gt;</b> to an incomplete type to hide the 
 			implementation. The instantiation of member functions which require a complete 
-			type occurs in the <A href="example/shared_ptr_example2.cpp">shared_ptr_example2.cpp</A>
+			type occurs in the <A href="shared_ptr_example2.cpp">shared_ptr_example2.cpp</A>
 			implementation file. Note that there is no need for an explicit destructor. 
 			Unlike ~scoped_ptr, ~shared_ptr does not require that <b>T</b> be a complete 
 			type.</p>
 		<h2><a name="ThreadSafety">Thread Safety</a></h2>
 		<p><STRONG>shared_ptr</STRONG> objects offer the same level of thread safety as 
-			built-in types. A <STRONG>shared_ptr</STRONG> instance can be "read" (accessed
+			built-in types. A <STRONG>shared_ptr</STRONG> instance can be "read" 
-			using only const operations) simultaneously by multiple threads. Different <STRONG>shared_ptr</STRONG>
+			(accessed using only const operations) simultaneously by multiple threads. 
-			instances can be "written to" (accessed using mutable operations such as <STRONG>operator=
+			Different <STRONG>shared_ptr</STRONG> instances can be "written to" (accessed 
-			</STRONG>or <STRONG>reset</STRONG>) simultaneosly by multiple threads (even
+			using mutable operations such as <STRONG>operator= </STRONG>or <STRONG>reset</STRONG>) 
-			when these instances are copies, and share the same reference count
+			simultaneosly by multiple threads (even when these instances are copies, and 
-			underneath.)</p>
+			share the same reference count underneath.)</p>
 		<P>Any other simultaneous accesses result in undefined behavior.</P>
 		<P>Examples:</P>
-		<pre>shared_ptr&lt;int&gt; p(new int(42));
+		<pre>
 shared_ptr&lt;int&gt; p(new int(42));
 //--- Example 1 ---
@@ -576,6 +577,7 @@ shared_ptr&lt;int&gt; p3(p); // OK, multiple reads are safe
 //--- Example 2 ---
 // thread A
 p.reset(new int(1912)); // writes p
 // thread B
@@ -605,90 +607,54 @@ p3.reset(new int(1));
 // thread B
 p3.reset(new int(2)); // undefined, multiple writes
 </pre>
-		<p>&nbsp;</p>
+		<p><STRONG>shared_ptr</STRONG> uses <A href="../config/config.htm">Boost.Config</A> 
-		<P>Starting with Boost release 1.33.0, <STRONG>shared_ptr</STRONG> uses a lock-free
+			to detect whether the implementation supports threads. If your program is 
-			implementation on the following platforms:</P>
+			single-threaded, but your platform is autodetected by <STRONG>Boost.Config</STRONG>
-		<UL>
+			as supporting multiple threads, <STRONG>#define BOOST_DISABLE_THREADS</STRONG> to 
-			<LI>
+			eliminate the thread safety overhead.</p>
 			GNU GCC on x86 or x86-64;
 			<LI>
 			GNU GCC on IA64;
 			<LI>
 			Metrowerks CodeWarrior on PowerPC;
 			<LI>
 			GNU GCC on PowerPC;
 			<LI>
 				Windows.</LI></UL>
 		<P>If your program is single-threaded and does not link to any libraries that might
 			have used <STRONG>shared_ptr</STRONG> in its default configuration, you can <STRONG>
 				#define</STRONG> the macro <STRONG>BOOST_SP_DISABLE_THREADS</STRONG> on a
 			project-wide basis to switch to ordinary non-atomic reference count updates.</P>
 		<P>(Defining <STRONG>BOOST_SP_DISABLE_THREADS</STRONG> in some, but not all,
 			translation units is technically a violation of the One Definition Rule and
 			undefined behavior. Nevertheless, the implementation attempts to do its best to
 			accommodate the request to use non-atomic updates in those translation units.
 			No guarantees, though.)</P>
 		<P>You can define the macro <STRONG>BOOST_SP_USE_PTHREADS</STRONG> to turn off the
 			lock-free platform-specific implementation and fall back to the generic <STRONG>pthread_mutex_t</STRONG>-based
 			code.</P>
 		<h2><a name="FAQ">Frequently Asked Questions</a></h2>
 		<P><B>Q.</B> There are several variations of shared pointers, with different 
 			tradeoffs; why does the smart pointer library supply only a single 
 			implementation? It would be useful to be able to experiment with each type so 
-			as to find the most suitable for the job at hand?</P>
+			as to find the most suitable for the job at hand?<BR>
 		<P>
 			<b>A.</b> An important goal of <STRONG>shared_ptr</STRONG> is to provide a 
 			standard shared-ownership pointer. Having a single pointer type is important 
 			for stable library interfaces, since different shared pointers typically cannot 
 			interoperate, i.e. a reference counted pointer (used by library A) cannot share 
-			ownership with a linked pointer (used by library B.)<BR>
+			ownership with a linked pointer (used by library B.)</P>
 		</P>
 		<P><B>Q.</B> Why doesn't <B>shared_ptr</B> have template parameters supplying 
-			traits or policies to allow extensive user customization?</P>
+			traits or policies to allow extensive user customization?<BR>
 		<P>
 			<B>A.</B> Parameterization discourages users. The <B>shared_ptr</B> template is 
 			carefully crafted to meet common needs without extensive parameterization. Some 
 			day a highly configurable smart pointer may be invented that is also very easy 
 			to use and very hard to misuse. Until then, <B>shared_ptr</B> is the smart 
 			pointer of choice for a wide range of applications. (Those interested in policy 
-			based smart pointers should read <A href="http://www.awprofessional.com/bookstore/product.asp?isbn=0201704315&amp;rl=1">
+			based smart pointers should read <A href="http://cseng.aw.com/book/0,,0201704315,00.html">
-				Modern C++ Design</A> by Andrei Alexandrescu.)<BR>
+				Modern C++ Design</A> by Andrei Alexandrescu.)</P>
 		</P>
 		<P><B>Q.</B> I am not convinced. Default parameters can be used where appropriate 
-			to hide the complexity. Again, why not policies?</P>
+			to hide the complexity. Again, why not policies?<BR>
 		<P>
 			<B>A.</B> Template parameters affect the type. See the answer to the first 
-			question above.<BR>
+			question above.</P>
-		</P>
+		<p><b>Q.</b> Why doesn't <b>shared_ptr</b> use a linked list implementation?<br>
 		<P><B>Q.</B> Why doesn't <b>shared_ptr</b> use a linked list implementation?</P>
 		<P>
 			<b>A.</b> A linked list implementation does not offer enough advantages to 
 			offset the added cost of an extra pointer. See <A href="smarttests.htm">timings</A>
 			page. In addition, it is expensive to make a linked list implementation thread 
-			safe.<BR>
+			safe.</p>
-		</P>
+		<p><b>Q.</b> Why doesn't <b>shared_ptr</b> (or any of the other Boost smart 
-		<P><b>Q.</b> Why doesn't <b>shared_ptr</b> (or any of the other Boost smart
+			pointers) supply an automatic conversion to <b>T*</b>?<br>
-			pointers) supply an automatic conversion to <b>T*</b>?</P>
+			<b>A.</b> Automatic conversion is believed to be too error prone.</p>
-		<P>
+		<p><b>Q.</b> Why does <b>shared_ptr</b> supply use_count()?<br>
 			<b>A.</b> Automatic conversion is believed to be too error prone.<BR>
 		</P>
 		<P><B>Q.</B> Why does <b>shared_ptr</b> supply use_count()?</P>
 		<P>
 			<b>A.</b> As an aid to writing test cases and debugging displays. One of the 
 			progenitors had use_count(), and it was useful in tracking down bugs in a 
-			complex project that turned out to have cyclic-dependencies.<BR>
+			complex project that turned out to have cyclic-dependencies.</p>
-		</P>
+		<p><b>Q.</b> Why doesn't <b>shared_ptr</b> specify complexity requirements?<br>
 		<P><B>Q.</B> Why doesn't <b>shared_ptr</b> specify complexity requirements?</P>
 		<P>
 			<b>A.</b> Because complexity requirements limit implementors and complicate the 
 			specification without apparent benefit to <b>shared_ptr</b> users. For example, 
 			error-checking implementations might become non-conforming if they had to meet 
-			stringent complexity requirements.<BR>
+			stringent complexity requirements.</p>
-		</P>
+		<p><b>Q.</b> Why doesn't <b>shared_ptr</b> provide a release() function?<br>
 		<P><b>Q.</b> Why doesn't <b>shared_ptr</b> provide a release() function?</P>
 		<P>
 			<b>A.</b> <b>shared_ptr</b> cannot give away ownership unless it's unique() 
-			because the other copy will still destroy the object.</P>
+			because the other copy will still destroy the object.</p>
 		<p>Consider:</p>
 		<blockquote><pre>shared_ptr&lt;int&gt; a(new int);
 shared_ptr&lt;int&gt; b(a); // a.use_count() == b.use_count() == 2
@@ -697,26 +663,16 @@ int * p = a.release();
 // Who owns p now? b will still call delete on it in its destructor.</pre>
 		</blockquote>
-		<p>Furthermore, the pointer returned by <code>release()</code> would be difficult
+		<p><b>Q.</b> Why doesn't <b>shared_ptr</b> provide (your pet feature here)?<br>
-			to deallocate reliably, as the source <b>shared_ptr</b> could have been created
+			<b>A.</b> Because (your pet feature here) would mandate a reference counted 
-			with a custom deleter.<BR>
+			implementation or a linked list implementation, or some other specific 
-		</p>
+			implementation. This is not the intent.</p>
 		<P><b>Q.</b> Why is <code>operator-&gt;()</code> const, but its return value is a
 			non-const pointer to the element type?</P>
 		<P>
 			<b>A.</b> Shallow copy pointers, including raw pointers, typically don't
 			propagate constness. It makes little sense for them to do so, as you can always
 			obtain a non-const pointer from a const one and then proceed to modify the
 			object through it.<b>shared_ptr</b> is "as close to raw pointers as possible
 			but no closer".<BR>
 			<BR>
 		</P>
 		<hr>
-		<p>
+		<p>Revised $Date$</p>
-			$Date$</p>
+		<p>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
-		<p><small>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler.
+			Copyright 2002 Peter Dimov. Permission to copy, use, modify, sell and 
-				Copyright 2002-2005 Peter Dimov. Distributed under the Boost Software License,
+			distribute this document is granted provided this copyright notice appears in 
-				Version 1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A>
+			all copies. This document is provided "as is" without express or implied 
-				or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
+			warranty, and with no claim as to its suitability for any purpose.</p>
 	</body>
 </html>
--- a/test/shared_ptr_assign_fail.cpp
+++ b/test/shared_ptr_assign_fail.cpp
@@ -1,6 +1,4 @@
-#include <boost/config.hpp>
+#if defined(_MSC_VER) && !defined(__ICL)
 #if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
@@ -12,9 +10,10 @@
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
-// Distributed under the Boost Software License, Version 1.0. (See
+//  Permission to copy, use, modify, sell and distribute this software
-// accompanying file LICENSE_1_0.txt or copy at
+//  is granted provided this copyright notice appears in all copies.
-// http://www.boost.org/LICENSE_1_0.txt)
+//  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 #include <boost/shared_ptr.hpp>
--- a/example/shared_ptr_example.cpp
+++ b/example/shared_ptr_example.cpp
@@ -1,11 +1,12 @@
 //  Boost shared_ptr_example.cpp  --------------------------------------------//
-//  Copyright Beman Dawes 2001.  Distributed under the Boost
+//  (C) Copyright Beman Dawes 2001. Permission to copy,
-//  Software License, Version 1.0. (See accompanying file
+//  use, modify, sell and distribute this software is granted provided this
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//  copyright notice appears in all copies. This software is provided "as is"
 //  without express or implied warranty, and with no claim as to its
 //  suitability for any purpose.
-
+//  See http://www.boost.org for most recent version including documentation.
 //  See http://www.boost.org/libs/smart_ptr for documentation.
 //  Revision History
 //  21 May 01  Initial complete version (Beman Dawes)
--- a/example/shared_ptr_example2.cpp
+++ b/example/shared_ptr_example2.cpp
@@ -1,12 +1,5 @@
 // Boost shared_ptr_example2 implementation file  -----------------------------//
 //  Copyright Beman Dawes 2001.  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)
 //  See http://www.boost.org/libs/smart_ptr for documentation.
 #include "shared_ptr_example2.hpp"
 #include <iostream>
@@ -17,6 +10,10 @@ class example::implementation
 };
 example::example() : _imp( new implementation ) {}
 example::example( const example & s ) : _imp( s._imp ) {}
 example & example::operator=( const example & s )
  { _imp = s._imp; return *this; }
 void example::do_something()
  { std::cout << "use_count() is " << _imp.use_count() << "\n"; }
--- a/example/shared_ptr_example2.hpp
+++ b/example/shared_ptr_example2.hpp
@@ -1,12 +1,5 @@
 //  Boost shared_ptr_example2 header file  -----------------------------------//
 //  Copyright Beman Dawes 2001.  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)
 //  See http://www.boost.org/libs/smart_ptr for documentation.
 #include <boost/shared_ptr.hpp>
 //  This example demonstrates the handle/body idiom (also called pimpl and
@@ -23,6 +16,8 @@ class example
 {
 public:
  example();
  example( const example & );
  example & operator=( const example & );
  void do_something();
 private:
  class implementation;
--- a/example/shared_ptr_example2_test.cpp
+++ b/example/shared_ptr_example2_test.cpp
@@ -1,12 +1,5 @@
 // Boost shared_ptr_example2_test main program  ------------------------------//
 //  Copyright Beman Dawes 2001.  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)
 //  See http://www.boost.org/libs/smart_ptr for documentation.
 #include "shared_ptr_example2.hpp"
 int main()
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
nobody	9fa591db1f	This commit was manufactured by cvs2svn to create tag 'Version_1_29_0'. [SVN r15904]	2002-10-11 15:17:55 +00:00
Peter Dimov	71a0c0ee97	Fixes, notes. [SVN r15487]	2002-09-23 13:32:54 +00:00
nobody	4990c9c83e	This commit was manufactured by cvs2svn to create branch 'RC_1_29_0'. [SVN r15460]	2002-09-19 20:49:39 +00:00