more boost stuff, necessary for base64 encoder and decoder

git-svn-id: svn://bind10.isc.org/svn/bind10/branches/parkinglot@726 e5f2f494-b856-4b98-b285-d166d9295462

84 files changed, 9904 insertions, 0 deletions

diff --git a/ext/boost/archive/iterators/base64_exception.hpp b/ext/boost/archive/iterators/base64_exception.hpp
new file mode 100644
index 0000000000..eb2d2e1ba0
--- /dev/null
+++ b/ext/boost/archive/iterators/base64_exception.hpp
@@ -0,0 +1,68 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_HPP
+#define BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// base64_exception.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_EXCEPTIONS
+#include <exception>
+
+#include <cassert>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by base64s
+//
+class base64_exception : public std::exception
+{
+public:
+    typedef enum {
+        invalid_code,       // attempt to encode a value > 6 bits
+        invalid_character,  // decode a value not in base64 char set
+        other_exception
+    } exception_code;
+    exception_code code;
+
+    base64_exception(exception_code c = other_exception) : code(c)
+    {}
+
+    virtual const char *what( ) const throw( )
+    {
+        const char *msg = "unknown exception code";
+        switch(code){
+        case invalid_code:
+            msg = "attempt to encode a value > 6 bits";
+            break;
+        case invalid_character:
+            msg = "attempt to decode a value not in base64 char set";
+            break;
+        default:
+            assert(false);
+            break;
+        }
+        return msg;
+    }
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif //BOOST_NO_EXCEPTIONS
+#endif //BOOST_ARCHIVE_ITERATORS_ARCHIVE_EXCEPTION_HPP
diff --git a/ext/boost/archive/iterators/base64_from_binary.hpp b/ext/boost/archive/iterators/base64_from_binary.hpp
new file mode 100644
index 0000000000..a46137d1d5
--- /dev/null
+++ b/ext/boost/archive/iterators/base64_from_binary.hpp
@@ -0,0 +1,112 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
+#define BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// base64_from_binary.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <cassert>
+
+#include <cstddef> // size_t
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/serialization/pfto.hpp>
+
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// convert binary integers to base64 characters
+
+namespace detail {
+
+template<class CharType>
+struct from_6_bit {
+    typedef CharType result_type;
+    CharType operator()(CharType t) const{
+        const char * lookup_table = 
+            "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+            "abcdefghijklmnopqrstuvwxyz"
+            "0123456789"
+            "+/";
+        assert(t < 64);
+        return lookup_table[static_cast<size_t>(t)];
+    }
+};
+
+} // namespace detail
+
+// note: what we would like to do is
+// template<class Base, class CharType = BOOST_DEDUCED_TYPENAME Base::value_type>
+//  typedef transform_iterator<
+//      from_6_bit<CharType>,
+//      transform_width<Base, 6, sizeof(Base::value_type) * 8, CharType>
+//  > base64_from_binary;
+// but C++ won't accept this.  Rather than using a "type generator" and
+// using a different syntax, make a derivation which should be equivalent.
+//
+// Another issue addressed here is that the transform_iterator doesn't have
+// a templated constructor.  This makes it incompatible with the dataflow
+// ideal.  This is also addressed here.
+
+//template<class Base, class CharType = BOOST_DEDUCED_TYPENAME Base::value_type>
+template<
+    class Base, 
+    class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type
+>
+class base64_from_binary : 
+    public transform_iterator<
+        detail::from_6_bit<CharType>,
+        Base
+    >
+{
+    friend class boost::iterator_core_access;
+    typedef transform_iterator<
+        BOOST_DEDUCED_TYPENAME detail::from_6_bit<CharType>,
+        Base
+    > super_t;
+
+public:
+    // make composible buy using templated constructor
+    template<class T>
+    base64_from_binary(BOOST_PFTO_WRAPPER(T) start) :
+        super_t(
+            Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start))),
+            detail::from_6_bit<CharType>()
+        )
+    {}
+    // intel 7.1 doesn't like default copy constructor
+    base64_from_binary(const base64_from_binary & rhs) : 
+        super_t(
+            Base(rhs.base_reference()),
+            detail::from_6_bit<CharType>()
+        )
+    {}
+//    base64_from_binary(){};
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
diff --git a/ext/boost/archive/iterators/binary_from_base64.hpp b/ext/boost/archive/iterators/binary_from_base64.hpp
new file mode 100644
index 0000000000..b75e0b10cc
--- /dev/null
+++ b/ext/boost/archive/iterators/binary_from_base64.hpp
@@ -0,0 +1,120 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
+#define BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// binary_from_base64.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <cassert>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/serialization/pfto.hpp>
+#include <boost/static_assert.hpp>
+
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// convert base64 characters to binary data
+
+namespace detail {
+
+template<class CharType>
+struct to_6_bit {
+    typedef CharType result_type;
+    CharType operator()(CharType t) const{
+        const char lookup_table[] = {
+            -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+            -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+            -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,
+            52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1,
+            -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
+            15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,
+            -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
+            41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1
+        };
+        // metrowerks trips this assertion - how come?
+        #if ! defined(__MWERKS__)
+        BOOST_STATIC_ASSERT(128 == sizeof(lookup_table));
+        #endif
+        signed char value = -1;
+        if((unsigned)t <= 127)
+            value = lookup_table[(unsigned)t];
+        if(-1 == value)
+            boost::serialization::throw_exception(
+                dataflow_exception(dataflow_exception::invalid_base64_character)
+            );
+        return value;
+    }
+};
+
+} // namespace detail
+
+// note: what we would like to do is
+// template<class Base, class CharType = BOOST_DEDUCED_TYPENAME Base::value_type>
+//  typedef transform_iterator<
+//      from_6_bit<CharType>,
+//      transform_width<Base, 6, sizeof(Base::value_type) * 8, CharType>
+//  > base64_from_binary;
+// but C++ won't accept this.  Rather than using a "type generator" and
+// using a different syntax, make a derivation which should be equivalent.
+//
+// Another issue addressed here is that the transform_iterator doesn't have
+// a templated constructor.  This makes it incompatible with the dataflow
+// ideal.  This is also addressed here.
+
+template<
+    class Base, 
+    class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type
+>
+class binary_from_base64 : public
+    transform_iterator<
+        detail::to_6_bit<CharType>,
+        Base
+    >
+{
+    friend class boost::iterator_core_access;
+    typedef transform_iterator<
+        detail::to_6_bit<CharType>,
+        Base
+    > super_t;
+public:
+    // make composible buy using templated constructor
+    template<class T>
+    binary_from_base64(BOOST_PFTO_WRAPPER(T)  start) :
+        super_t(
+            Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start))), 
+            detail::to_6_bit<CharType>()
+        )
+    {}
+    // intel 7.1 doesn't like default copy constructor
+    binary_from_base64(const binary_from_base64 & rhs) : 
+        super_t(
+            Base(rhs.base_reference()),
+            detail::to_6_bit<CharType>()
+        )
+    {}
+//    binary_from_base64(){};
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
diff --git a/ext/boost/archive/iterators/dataflow.hpp b/ext/boost/archive/iterators/dataflow.hpp
new file mode 100644
index 0000000000..7958482401
--- /dev/null
+++ b/ext/boost/archive/iterators/dataflow.hpp
@@ -0,0 +1,105 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
+#define BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// dataflow.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <cassert>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/plus.hpp>
+#include <boost/mpl/int.hpp>
+
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+#include <boost/static_assert.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+// poor man's tri-state
+struct tri_state {
+    enum state_enum {
+        is_false = false,
+        is_true = true,
+        is_indeterminant
+    } m_state;
+    // convert to bool
+    operator bool (){
+        assert(is_indeterminant != m_state);
+        return is_true == m_state ? true : false;
+    }
+    // assign from bool
+    tri_state & operator=(bool rhs) {
+        m_state = rhs ? is_true : is_false;
+        return *this;
+    }
+    tri_state(bool rhs) :
+        m_state(rhs ? is_true : is_false)
+    {}
+    tri_state(state_enum state) :
+        m_state(state)
+    {}
+    bool operator==(const tri_state & rhs) const {
+        return m_state == rhs.m_state;
+    }
+    bool operator!=(const tri_state & rhs) const {
+        return m_state != rhs.m_state;
+    }
+};
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implement functions common to dataflow iterators
+template<class Derived>
+class dataflow {
+    bool m_eoi;
+protected:
+    // test for iterator equality
+    tri_state equal(const Derived & rhs) const {
+        if(m_eoi && rhs.m_eoi)
+            return true;
+        if(m_eoi || rhs.m_eoi)
+            return false;
+        return tri_state(tri_state::is_indeterminant);
+    }
+    void eoi(bool tf){
+        m_eoi = tf;
+    }
+    bool eoi() const {
+        return m_eoi;
+    }
+public:
+    dataflow(bool tf) :
+        m_eoi(tf)
+    {}
+    dataflow() : // used for iterator end
+        m_eoi(true)
+    {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
diff --git a/ext/boost/archive/iterators/dataflow_exception.hpp b/ext/boost/archive/iterators/dataflow_exception.hpp
new file mode 100644
index 0000000000..765661e470
--- /dev/null
+++ b/ext/boost/archive/iterators/dataflow_exception.hpp
@@ -0,0 +1,80 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
+#define BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// dataflow_exception.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_EXCEPTIONS
+#include <exception>
+#endif //BOOST_NO_EXCEPTIONS
+
+#include <cassert>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by dataflows
+//
+class dataflow_exception : public std::exception
+{
+public:
+    typedef enum {
+        invalid_6_bitcode,
+        invalid_base64_character,
+        invalid_xml_escape_sequence,
+        comparison_not_permitted,
+        invalid_conversion,
+        other_exception
+    } exception_code;
+    exception_code code;
+
+    dataflow_exception(exception_code c = other_exception) : code(c)
+    {}
+
+    virtual const char *what( ) const throw( )
+    {
+        const char *msg = "unknown exception code";
+        switch(code){
+        case invalid_6_bitcode:
+            msg = "attempt to encode a value > 6 bits";
+            break;
+        case invalid_base64_character:
+            msg = "attempt to decode a value not in base64 char set";
+            break;
+        case invalid_xml_escape_sequence:
+            msg = "invalid xml escape_sequence";
+            break;
+        case comparison_not_permitted:
+            msg = "cannot invoke iterator comparison now";
+            break;
+        case invalid_conversion:
+            msg = "invalid multbyte/wide char conversion";
+            break;
+        default:
+            assert(false);
+            break;
+        }
+        return msg;
+    }
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif //BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
diff --git a/ext/boost/archive/iterators/escape.hpp b/ext/boost/archive/iterators/escape.hpp
new file mode 100644
index 0000000000..3fe64fa49f
--- /dev/null
+++ b/ext/boost/archive/iterators/escape.hpp
@@ -0,0 +1,115 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
+#define BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// escape.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <cassert>
+#include <cstddef> // NULL
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// insert escapes into text
+
+template<class Derived, class Base>
+class escape : 
+    public boost::iterator_adaptor<
+        Derived, 
+        Base, 
+        BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type,
+        single_pass_traversal_tag,
+        BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type
+    >
+{
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type base_value_type;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<Base>::type reference_type;
+    friend class boost::iterator_core_access;
+
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor<
+        Derived, 
+        Base, 
+        base_value_type,
+        single_pass_traversal_tag,
+        base_value_type
+    > super_t;
+
+    typedef escape<Derived, Base> this_t;
+
+    void dereference_impl() {
+        m_current_value = static_cast<Derived *>(this)->fill(m_bnext, m_bend);
+        m_full = true;
+    }
+
+    //Access the value referred to 
+    reference_type dereference() const {
+        if(!m_full)
+            const_cast<this_t *>(this)->dereference_impl();
+        return m_current_value;
+    }
+
+    bool equal(const this_t & rhs) const {
+        if(m_full){
+            if(! rhs.m_full)
+                const_cast<this_t *>(& rhs)->dereference_impl();
+        }
+        else{
+            if(rhs.m_full)
+                const_cast<this_t *>(this)->dereference_impl();
+        }
+        if(m_bnext != rhs.m_bnext)
+            return false;
+        if(this->base_reference() != rhs.base_reference())
+            return false;
+        return true;
+    }
+
+   void increment(){
+        if(++m_bnext < m_bend){
+            m_current_value = *m_bnext;
+            return;
+        }
+        ++(this->base_reference());
+        m_bnext = NULL;
+        m_bend = NULL;
+        m_full = false;
+    }
+
+    // buffer to handle pending characters
+    const base_value_type *m_bnext;
+    const base_value_type *m_bend;
+    bool m_full;
+    BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type m_current_value;
+public:
+    escape(Base base) : 
+        super_t(base),
+        m_bnext(NULL),
+        m_bend(NULL),
+        m_full(false)
+    {
+    }
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
diff --git a/ext/boost/archive/iterators/head_iterator.hpp b/ext/boost/archive/iterators/head_iterator.hpp
new file mode 100644
index 0000000000..279b2025ce
--- /dev/null
+++ b/ext/boost/archive/iterators/head_iterator.hpp
@@ -0,0 +1,81 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_HEAD_ITERATOR_HPP
+#define BOOST_ARCHIVE_ITERATORS_HEAD_ITERATOR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// head_iterator.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+template<class Predicate, class Base>
+class head_iterator
+    : public boost::iterator_adaptor<
+        head_iterator<Predicate, Base>,
+        Base,
+        use_default,
+        single_pass_traversal_tag
+    >
+{
+private:
+    friend class iterator_core_access;
+    typedef boost::iterator_adaptor<
+        head_iterator<Predicate, Base>,
+        Base,
+        use_default,
+        single_pass_traversal_tag
+    > super_t;
+
+    typedef head_iterator<Predicate, Base> this_t;
+    typedef BOOST_DEDUCED_TYPENAME super_t::value_type value_type;
+    typedef BOOST_DEDUCED_TYPENAME super_t::reference reference_type;
+
+    reference_type dereference_impl(){
+        if(! m_end){
+            while(! m_predicate(* this->base_reference()))
+                ++ this->base_reference();
+            m_end = true;
+        }
+        return * this->base_reference();
+    }
+
+    reference_type dereference() const {
+        return const_cast<this_t *>(this)->dereference_impl();
+    }
+
+    void increment(){
+        ++base_reference();
+    }
+    Predicate m_predicate;
+    bool m_end;
+public:
+    template<class T>
+    head_iterator(Predicate f, T start) : 
+        super_t(Base(start)), 
+        m_predicate(f),
+        m_end(false)
+    {}
+
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_HEAD_ITERATOR_HPP
diff --git a/ext/boost/archive/iterators/insert_linebreaks.hpp b/ext/boost/archive/iterators/insert_linebreaks.hpp
new file mode 100644
index 0000000000..feb8c5bb84
--- /dev/null
+++ b/ext/boost/archive/iterators/insert_linebreaks.hpp
@@ -0,0 +1,101 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
+#define BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// insert_linebreaks.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <cassert>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ using ::memcpy; }
+#endif
+
+#include <boost/serialization/pfto.hpp>
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// insert line break every N characters
+template<
+    class Base, 
+    int N, 
+    class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type
+>
+class insert_linebreaks : 
+    public iterator_adaptor<
+        insert_linebreaks<Base, N, CharType>,
+        Base,
+        CharType,
+        single_pass_traversal_tag,
+        CharType
+    >
+{
+private:
+    friend class boost::iterator_core_access;
+    typedef iterator_adaptor<
+        insert_linebreaks<Base, N, CharType>,
+        Base,
+        CharType,
+        single_pass_traversal_tag,
+        CharType
+    > super_t;
+
+    bool equal(const insert_linebreaks<Base, N, CharType> & rhs) const {
+        return
+//            m_count == rhs.m_count
+//            && base_reference() == rhs.base_reference()
+            this->base_reference() == rhs.base_reference()
+        ;
+    }
+
+    void increment() {
+        if(m_count == N){
+            m_count = 0;
+            return;
+        }
+        ++m_count;
+        ++(this->base_reference());
+    }
+    CharType dereference() const {
+        if(m_count == N)
+            return '\n';
+        return * (this->base_reference());
+    }
+    unsigned int m_count;
+public:
+    // make composible buy using templated constructor
+    template<class T>
+    insert_linebreaks(BOOST_PFTO_WRAPPER(T)  start) :
+        super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start)))),
+        m_count(0)
+    {}
+    // intel 7.1 doesn't like default copy constructor
+    insert_linebreaks(const insert_linebreaks & rhs) : 
+        super_t(rhs.base_reference()),
+        m_count(rhs.m_count)
+    {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
diff --git a/ext/boost/archive/iterators/istream_iterator.hpp b/ext/boost/archive/iterators/istream_iterator.hpp
new file mode 100644
index 0000000000..ac3568aa87
--- /dev/null
+++ b/ext/boost/archive/iterators/istream_iterator.hpp
@@ -0,0 +1,95 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
+#define BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// istream_iterator.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+// note: this is a custom version of the standard istream_iterator.
+// This is necessary as the standard version doesn't work as expected
+// for wchar_t based streams on systems for which wchar_t not a true
+// type but rather a synonym for some integer type.
+
+#include <cstddef> // NULL
+#include <istream>
+#include <boost/iterator/iterator_facade.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+// given a type, make an input iterator based on a pointer to that type
+template<class Elem = char>
+class istream_iterator :  
+    public boost::iterator_facade<
+        istream_iterator<Elem>,
+        Elem,
+        std::input_iterator_tag,
+        Elem
+    >
+{
+    friend class boost::iterator_core_access;
+    typedef istream_iterator this_t ;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_facade<
+        istream_iterator<Elem>,
+        Elem,
+        std::input_iterator_tag,
+        Elem
+    > super_t;
+    typedef BOOST_DEDUCED_TYPENAME std::basic_istream<Elem> istream_type;
+ 
+    //Access the value referred to 
+    Elem dereference() const {
+        return m_current_value;
+    }
+
+    bool equal(const this_t & rhs) const {
+        // note: only  works for comparison against end of stream
+        return m_istream == rhs.m_istream;
+    }
+
+    void increment(){
+        if(NULL != m_istream){
+            m_current_value = m_istream->get();
+            if(! m_istream->good()){
+                const_cast<this_t *>(this)->m_istream = NULL;
+            }
+        }
+    }
+
+    istream_type *m_istream;
+    Elem m_current_value;
+public:
+    istream_iterator(istream_type & is) :
+        m_istream(& is)
+    {
+        increment();
+    }
+
+    istream_iterator() :
+        m_istream(NULL)
+    {}
+
+    istream_iterator(const istream_iterator<Elem> & rhs) :
+        m_istream(rhs.m_istream),
+        m_current_value(rhs.m_current_value)
+    {}
+
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
diff --git a/ext/boost/archive/iterators/mb_from_wchar.hpp b/ext/boost/archive/iterators/mb_from_wchar.hpp
new file mode 100644
index 0000000000..22ee9504e5
--- /dev/null
+++ b/ext/boost/archive/iterators/mb_from_wchar.hpp
@@ -0,0 +1,136 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
+#define BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// mb_from_wchar.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <cassert>
+#include <cstddef> // size_t
+#include <cstdlib> // for wctomb()
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+    using ::wctomb;
+} // namespace std
+#endif
+
+#include <boost/serialization/pfto.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// class used by text archives to translate wide strings and to char
+// strings of the currently selected locale
+template<class Base>    // the input iterator
+class mb_from_wchar
+    : public boost::iterator_adaptor<
+        mb_from_wchar<Base>, 
+        Base, 
+        wchar_t,
+        single_pass_traversal_tag,
+        char
+    >
+{
+    friend class boost::iterator_core_access;
+
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor<
+        mb_from_wchar<Base>, 
+        Base, 
+        wchar_t,
+        single_pass_traversal_tag,
+        char
+    > super_t;
+
+    typedef mb_from_wchar<Base> this_t;
+
+    char dereference_impl() {
+        if(! m_full){
+            fill();
+            m_full = true;
+        }
+        return m_buffer[m_bnext];
+    }
+    char dereference() const {
+        return (const_cast<this_t *>(this))->dereference_impl();
+    }
+
+    // test for iterator equality
+    bool equal(const mb_from_wchar<Base> & rhs) const {
+        // once the value is filled, the base_reference has been incremented
+        // so don't permit comparison anymore.
+        return 
+            0 == m_bend
+            && 0 == m_bnext
+            && this->base_reference() == rhs.base_reference()
+        ;
+    }
+
+    void fill(){
+        wchar_t value = * this->base_reference();
+        #if (defined(__MINGW32__) && ((__MINGW32_MAJOR_VERSION > 3) \
+        || ((__MINGW32_MAJOR_VERSION == 3) && (__MINGW32_MINOR_VERSION >= 8))))
+        m_bend = std::wcrtomb(m_buffer, value, 0);
+        #else
+        m_bend = std::wctomb(m_buffer, value);
+        #endif
+        assert(-1 != m_bend);
+        assert((std::size_t)m_bend <= sizeof(m_buffer));
+        assert(m_bend > 0);
+        m_bnext = 0;
+    }
+
+    void increment(){
+        if(++m_bnext < m_bend)
+            return;
+        m_bend = 
+        m_bnext = 0;
+        ++(this->base_reference());
+        m_full = false;
+    }
+
+    // buffer to handle pending characters
+    int m_bend;
+    int m_bnext;
+    char m_buffer[9];
+    bool m_full;
+
+public:
+    // make composible buy using templated constructor
+    template<class T>
+    mb_from_wchar(BOOST_PFTO_WRAPPER(T) start) :
+        super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start)))),
+        m_bend(0),
+        m_bnext(0),
+        m_full(false)
+    {}
+    // intel 7.1 doesn't like default copy constructor
+    mb_from_wchar(const mb_from_wchar & rhs) : 
+        super_t(rhs.base_reference()),
+        m_bend(rhs.m_bend),
+        m_bnext(rhs.m_bnext),
+        m_full(rhs.m_full)
+    {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
diff --git a/ext/boost/archive/iterators/ostream_iterator.hpp b/ext/boost/archive/iterators/ostream_iterator.hpp
new file mode 100644
index 0000000000..7c3203f125
--- /dev/null
+++ b/ext/boost/archive/iterators/ostream_iterator.hpp
@@ -0,0 +1,83 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
+#define BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// ostream_iterator.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+// note: this is a custom version of the standard ostream_iterator.
+// This is necessary as the standard version doesn't work as expected
+// for wchar_t based streams on systems for which wchar_t not a true
+// type but rather a synonym for some integer type.
+
+#include <ostream>
+#include <boost/iterator/iterator_facade.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+// given a type, make an input iterator based on a pointer to that type
+template<class Elem>
+class ostream_iterator :  
+    public boost::iterator_facade<
+        ostream_iterator<Elem>,
+        Elem,
+        std::output_iterator_tag,
+        ostream_iterator<Elem> &
+    >
+{
+    friend class boost::iterator_core_access;
+    typedef ostream_iterator this_t ;
+    typedef Elem char_type;
+    typedef std::basic_ostream<char_type> ostream_type;
+
+    //emulate the behavior of std::ostream 
+    ostream_iterator & dereference() const {
+        return const_cast<ostream_iterator &>(*this);
+    }
+    bool equal(const this_t & rhs) const {
+        return m_ostream == rhs.m_ostream;
+    }
+    void increment(){}
+protected:
+    ostream_type *m_ostream;
+    void put_val(char_type e){
+        if(NULL != m_ostream){
+            m_ostream->put(e);
+            if(! m_ostream->good())
+                m_ostream = NULL;
+        }
+    }
+public:
+    this_t & operator=(char_type c){
+        put_val(c);
+        return *this;
+    }
+    ostream_iterator(ostream_type & os) :
+        m_ostream (& os)
+    {}
+    ostream_iterator() :
+        m_ostream (NULL)
+    {}
+    ostream_iterator(const ostream_iterator & rhs) :
+        m_ostream (rhs.m_ostream)
+    {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
diff --git a/ext/boost/archive/iterators/remove_whitespace.hpp b/ext/boost/archive/iterators/remove_whitespace.hpp
new file mode 100644
index 0000000000..c5e581d99f
--- /dev/null
+++ b/ext/boost/archive/iterators/remove_whitespace.hpp
@@ -0,0 +1,169 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
+#define BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// remove_whitespace.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <cassert>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+
+#include <boost/serialization/pfto.hpp>
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/filter_iterator.hpp>
+
+//#include <boost/detail/workaround.hpp>
+//#if ! BOOST_WORKAROUND(BOOST_MSVC, <=1300)
+
+// here is the default standard implementation of the functor used
+// by the filter iterator to remove spaces.  Unfortunately usage
+// of this implementation in combination with spirit trips a bug
+// VC 6.5.  The only way I can find to work around it is to 
+// implement a special non-standard version for this platform
+
+#ifndef BOOST_NO_CWCTYPE
+#include <cwctype> // iswspace
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ using ::iswspace; }
+#endif
+#endif
+
+#include <cctype> // isspace
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ using ::isspace; }
+#endif
+
+#if defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
+// this is required for the RW STL on Linux and Tru64.
+#undef isspace
+#undef iswspace
+#endif
+
+//#endif // BOOST_WORKAROUND
+
+namespace { // anonymous
+
+template<class CharType>
+struct remove_whitespace_predicate;
+
+template<>
+struct remove_whitespace_predicate<char>
+{
+    bool operator()(unsigned char t){
+        return ! std::isspace(t);
+    }
+};
+
+#ifndef BOOST_NO_CWCHAR
+template<>
+struct remove_whitespace_predicate<wchar_t>
+{
+    bool operator()(wchar_t t){
+        return ! std::iswspace(t);
+    }
+};
+#endif
+
+} // namespace anonymous
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// convert base64 file data (including whitespace and padding) to binary
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+// custom version of filter iterator which doesn't look ahead further than
+// necessary
+
+template<class Predicate, class Base>
+class filter_iterator
+    : public boost::iterator_adaptor<
+        filter_iterator<Predicate, Base>,
+        Base,
+        use_default,
+        single_pass_traversal_tag
+    >
+{
+    friend class boost::iterator_core_access;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor<
+        filter_iterator<Predicate, Base>,
+        Base,
+        use_default,
+        single_pass_traversal_tag
+    > super_t;
+    typedef filter_iterator<Predicate, Base> this_t;
+    typedef BOOST_DEDUCED_TYPENAME super_t::reference reference_type;
+
+    reference_type dereference_impl(){
+        if(! m_full){
+            while(! m_predicate(* this->base_reference()))
+                ++(this->base_reference());
+            m_full = true;
+        }
+        return * this->base_reference();
+    }
+
+    reference_type dereference() const {
+        return const_cast<this_t *>(this)->dereference_impl();
+    }
+
+    Predicate m_predicate;
+    bool m_full;
+public:
+    // note: this function is public only because comeau compiler complained
+    // I don't know if this is because the compiler is wrong or what
+    void increment(){
+        m_full = false;
+        ++(this->base_reference());
+    }
+    filter_iterator(Base start) : 
+        super_t(start), 
+        m_full(false)
+    {}
+    filter_iterator(){}
+};
+
+template<class Base>
+class remove_whitespace : 
+    public filter_iterator<
+        remove_whitespace_predicate<BOOST_DEDUCED_TYPENAME Base::value_type>,
+        Base
+    >
+{
+    friend class boost::iterator_core_access;
+    typedef filter_iterator<
+        remove_whitespace_predicate<BOOST_DEDUCED_TYPENAME Base::value_type>,
+        Base
+    > super_t;
+public:
+//    remove_whitespace(){} // why is this needed?
+    // make composible buy using templated constructor
+    template<class T>
+    remove_whitespace(BOOST_PFTO_WRAPPER(T) start) :
+        super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start))))
+    {}
+    // intel 7.1 doesn't like default copy constructor
+    remove_whitespace(const remove_whitespace & rhs) : 
+        super_t(rhs.base_reference())
+    {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
diff --git a/ext/boost/archive/iterators/transform_width.hpp b/ext/boost/archive/iterators/transform_width.hpp
new file mode 100644
index 0000000000..c2e9bee12e
--- /dev/null
+++ b/ext/boost/archive/iterators/transform_width.hpp
@@ -0,0 +1,168 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
+#define BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// transform_width.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+// iterator which takes elements of x bits and returns elements of y bits.
+// used to change streams of 8 bit characters into streams of 6 bit characters.
+// and vice-versa for implementing base64 encodeing/decoding. Be very careful
+// when using and end iterator.  end is only reliable detected when the input
+// stream length is some common multiple of x and y.  E.G. Base64 6 bit
+// character and 8 bit bytes. Lowest common multiple is 24 => 4 6 bit characters
+// or 3 8 bit characters
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME & PTFO
+#include <boost/serialization/pfto.hpp>
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// class used by text archives to translate char strings to wchar_t
+// strings of the currently selected locale
+template<
+    class Base, 
+    int BitsOut, 
+    int BitsIn, 
+    class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type // output character
+>
+class transform_width : 
+    public boost::iterator_adaptor<
+        transform_width<Base, BitsOut, BitsIn, CharType>,
+        Base,
+        CharType,
+        single_pass_traversal_tag,
+        CharType
+    >
+{
+    friend class boost::iterator_core_access;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor<
+        transform_width<Base, BitsOut, BitsIn, CharType>,
+        Base,
+        CharType,
+        single_pass_traversal_tag,
+        CharType
+    > super_t;
+
+    typedef transform_width<Base, BitsOut, BitsIn, CharType> this_t;
+    typedef BOOST_DEDUCED_TYPENAME iterator_value<Base>::type base_value_type;
+
+    CharType fill();
+
+    CharType dereference_impl(){
+        if(! m_full){
+            m_current_value = fill();
+            m_full = true;
+        }
+        return m_current_value;
+    }
+
+    CharType dereference() const {
+        return const_cast<this_t *>(this)->dereference_impl();
+    }
+
+    // test for iterator equality
+    bool equal(const this_t & rhs) const {
+        return
+            this->base_reference() == rhs.base_reference();
+        ;
+    }
+
+    void increment(){
+        m_displacement += BitsOut;
+
+        while(m_displacement >= BitsIn){
+            m_displacement -= BitsIn;
+            if(0 == m_displacement)
+                m_bufferfull = false;
+            if(! m_bufferfull){
+                // note: suspect that this is not invoked for borland
+                ++(this->base_reference());
+            }
+        }
+        m_full = false;
+    }
+
+    CharType m_current_value;
+    // number of bits left in current input character buffer
+    unsigned int m_displacement;
+    base_value_type m_buffer;
+    // flag to current output character is ready - just used to save time
+    bool m_full;
+    // flag to indicate that m_buffer has data
+    bool m_bufferfull;
+
+public:
+    // make composible buy using templated constructor
+    template<class T>
+    transform_width(BOOST_PFTO_WRAPPER(T) start) : 
+        super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start)))),
+        m_displacement(0),
+        m_full(false),
+        m_bufferfull(false)
+    {}
+    // intel 7.1 doesn't like default copy constructor
+    transform_width(const transform_width & rhs) : 
+        super_t(rhs.base_reference()),
+        m_current_value(rhs.m_current_value),
+        m_displacement(rhs.m_displacement),
+        m_buffer(rhs.m_buffer),
+        m_full(rhs.m_full),
+        m_bufferfull(rhs.m_bufferfull)
+    {}
+};
+
+template<class Base, int BitsOut, int BitsIn, class CharType>
+CharType transform_width<Base, BitsOut, BitsIn, CharType>::fill(){
+    CharType retval = 0;
+    unsigned int missing_bits = BitsOut;
+    for(;;){
+        unsigned int bcount;
+        if(! m_bufferfull){
+            m_buffer = * this->base_reference();
+            m_bufferfull = true;
+            bcount = BitsIn;
+        }
+        else
+            bcount = BitsIn - m_displacement;
+        unsigned int i = (std::min)(bcount, missing_bits);
+        // shift interesting bits to least significant position
+        unsigned int j = m_buffer >> (bcount - i);
+        // strip off uninteresting bits
+        // (note presumption of two's complement arithmetic)
+        j &= ~(-(1 << i));
+        // append then interesting bits to the output value
+        retval <<= i;
+        retval |= j;
+        missing_bits -= i;
+        if(0 == missing_bits)
+            break;
+        // note: suspect that this is not invoked for borland 5.51
+        ++(this->base_reference());
+        m_bufferfull = false;
+    }
+    return retval;
+}
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
diff --git a/ext/boost/archive/iterators/unescape.hpp b/ext/boost/archive/iterators/unescape.hpp
new file mode 100644
index 0000000000..e709138181
--- /dev/null
+++ b/ext/boost/archive/iterators/unescape.hpp
@@ -0,0 +1,94 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
+#define BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// unescape.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <cassert>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#include <boost/iterator/iterator_adaptor.hpp>
+//#include <boost/iterator/iterator_traits.hpp>
+#include <boost/pointee.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// class used by text archives to translate char strings to wchar_t
+// strings of the currently selected locale
+template<class Derived, class Base>
+class unescape 
+    : public boost::iterator_adaptor<
+        unescape<Derived, Base>,
+        Base, 
+        BOOST_DEDUCED_TYPENAME pointee<Base>::type,
+        single_pass_traversal_tag,
+        BOOST_DEDUCED_TYPENAME pointee<Base>::type
+    >
+{
+    friend class boost::iterator_core_access;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor<
+        unescape<Derived, Base>, 
+        Base, 
+        BOOST_DEDUCED_TYPENAME pointee<Base>::type,
+        single_pass_traversal_tag,
+        BOOST_DEDUCED_TYPENAME pointee<Base>::type
+    > super_t;
+
+    typedef unescape<Derived, Base> this_t;
+    typedef BOOST_DEDUCED_TYPENAME super_t::reference reference_type;
+public:
+    // gcc 3.4.1 - linux required that this be public
+    typedef BOOST_DEDUCED_TYPENAME super_t::value_type value_type;
+private:
+
+    reference_type dereference_impl() {
+        if(! m_full){
+            m_current_value = static_cast<Derived *>(this)->drain();
+            m_full = true;
+        }
+        return m_current_value;
+    }
+
+    reference_type dereference() const {
+        return const_cast<this_t *>(this)->dereference_impl();
+    }
+
+    // value_type is const char - can't be const fix later
+    value_type m_current_value;
+    bool m_full;
+
+    void increment(){
+        ++(this->base_reference());
+        dereference_impl();
+        m_full = false;
+    };
+
+public:
+
+    unescape(Base base) : 
+        super_t(base),
+        m_full(false)
+    {}
+
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
diff --git a/ext/boost/archive/iterators/wchar_from_mb.hpp b/ext/boost/archive/iterators/wchar_from_mb.hpp
new file mode 100644
index 0000000000..18f06225f9
--- /dev/null
+++ b/ext/boost/archive/iterators/wchar_from_mb.hpp
@@ -0,0 +1,129 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
+#define BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// wchar_from_mb.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <cassert>
+#include <cctype>
+#include <cstddef> // size_t
+#include <cstdlib> // mblen
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::mblen; 
+    using ::mbtowc; 
+} // namespace std
+#endif
+
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/serialization/pfto.hpp>
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// class used by text archives to translate char strings to wchar_t
+// strings of the currently selected locale
+template<class Base>
+class wchar_from_mb 
+    : public boost::iterator_adaptor<
+        wchar_from_mb<Base>, 
+        Base, 
+        wchar_t,
+        single_pass_traversal_tag,
+        wchar_t
+    >
+{
+    friend class boost::iterator_core_access;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor<
+        wchar_from_mb<Base>, 
+        Base, 
+        wchar_t,
+        single_pass_traversal_tag,
+        wchar_t
+    > super_t;
+
+    typedef wchar_from_mb<Base> this_t;
+
+    wchar_t drain();
+
+    wchar_t dereference_impl() {
+        if(! m_full){
+            m_current_value = drain();
+            m_full = true;
+        }
+        return m_current_value;
+    }
+
+    wchar_t dereference() const {
+        return const_cast<this_t *>(this)->dereference_impl();
+    }
+
+    void increment(){
+        dereference_impl();
+        m_full = false;
+        ++(this->base_reference());
+    };
+
+    wchar_t m_current_value;
+    bool m_full;
+
+public:
+    // make composible buy using templated constructor
+    template<class T>
+    wchar_from_mb(BOOST_PFTO_WRAPPER(T) start) : 
+        super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start)))),
+        m_full(false)
+    {}
+    // intel 7.1 doesn't like default copy constructor
+    wchar_from_mb(const wchar_from_mb & rhs) : 
+        super_t(rhs.base_reference()),
+        m_full(rhs.m_full)
+    {}
+};
+
+template<class Base>
+wchar_t wchar_from_mb<Base>::drain(){
+    char buffer[9];
+    char * bptr = buffer;
+    char val;
+    for(std::size_t i = 0; i++ < (unsigned)MB_CUR_MAX;){
+        val = * this->base_reference();
+        *bptr++ = val;
+        int result = std::mblen(buffer, i);
+        if(-1 != result)
+            break;
+        ++(this->base_reference());
+    }
+    wchar_t retval;
+    int result = std::mbtowc(& retval, buffer, MB_CUR_MAX);
+    if(0 >= result)
+        boost::serialization::throw_exception(iterators::dataflow_exception(
+            iterators::dataflow_exception::invalid_conversion
+        ));
+    return retval;
+}
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
diff --git a/ext/boost/archive/iterators/xml_escape.hpp b/ext/boost/archive/iterators/xml_escape.hpp
new file mode 100644
index 0000000000..8eb87f4246
--- /dev/null
+++ b/ext/boost/archive/iterators/xml_escape.hpp
@@ -0,0 +1,125 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
+#define BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_escape.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <cassert>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#include <boost/serialization/pfto.hpp>
+
+#include <boost/archive/iterators/escape.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// insert escapes into xml text
+
+template<class Base>
+class xml_escape 
+    : public escape<xml_escape<Base>, Base>
+{
+    friend class boost::iterator_core_access;
+
+    typedef escape<xml_escape<Base>, Base> super_t;
+
+public:
+    char fill(const char * & bstart, const char * & bend);
+    wchar_t fill(const wchar_t * & bstart, const wchar_t * & bend);
+
+    template<class T>
+    xml_escape(BOOST_PFTO_WRAPPER(T) start) :
+        super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start))))
+    {}
+    // intel 7.1 doesn't like default copy constructor
+    xml_escape(const xml_escape & rhs) : 
+        super_t(rhs.base_reference())
+    {}
+};
+
+template<class Base>
+char xml_escape<Base>::fill(
+    const char * & bstart, 
+    const char * & bend
+){
+    char current_value = * this->base_reference();
+    switch(current_value){
+    case '<':
+        bstart = "&lt;";
+        bend = bstart + 4;
+        break;
+    case '>':
+        bstart = "&gt;";
+        bend = bstart + 4;
+        break;
+    case '&':
+        bstart = "&amp;";
+        bend = bstart + 5;
+        break;
+    case '"':
+        bstart = "&quot;";
+        bend = bstart + 6;
+        break;
+    case '\'':
+        bstart = "&apos;";
+        bend = bstart + 6;
+        break;
+    default:
+        return current_value;
+    }
+    return *bstart;
+}
+
+template<class Base>
+wchar_t xml_escape<Base>::fill(
+    const wchar_t * & bstart, 
+    const wchar_t * & bend
+){
+    wchar_t current_value = * this->base_reference();
+    switch(current_value){
+    case '<':
+        bstart = L"&lt;";
+        bend = bstart + 4;
+        break;
+    case '>':
+        bstart = L"&gt;";
+        bend = bstart + 4;
+        break;
+    case '&':
+        bstart = L"&amp;";
+        bend = bstart + 5;
+        break;
+    case '"':
+        bstart = L"&quot;";
+        bend = bstart + 6;
+        break;
+    case '\'':
+        bstart = L"&apos;";
+        bend = bstart + 6;
+        break;
+    default:
+        return current_value;
+    }
+    return *bstart;
+}
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
diff --git a/ext/boost/archive/iterators/xml_unescape.hpp b/ext/boost/archive/iterators/xml_unescape.hpp
new file mode 100644
index 0000000000..4272c9786e
--- /dev/null
+++ b/ext/boost/archive/iterators/xml_unescape.hpp
@@ -0,0 +1,118 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
+#define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_unescape.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <cassert>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/serialization/pfto.hpp>
+
+#include <boost/archive/iterators/unescape.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// replace &??? xml escape sequences with the corresponding characters
+template<class Base>
+class xml_unescape 
+    : public unescape<xml_unescape<Base>, Base>
+{
+    friend class boost::iterator_core_access;
+    typedef xml_unescape<Base> this_t;
+    typedef unescape<this_t, Base> super_t;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<this_t> reference_type;
+
+    reference_type dereference() const {
+        return unescape<xml_unescape<Base>, Base>::dereference();
+    }
+public:
+    void drain_residue(const char *literal);
+    int drain();
+
+    template<class T>
+    xml_unescape(BOOST_PFTO_WRAPPER(T) start) : 
+        super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start))))
+    {}
+    // intel 7.1 doesn't like default copy constructor
+    xml_unescape(const xml_unescape & rhs) : 
+        super_t(rhs.base_reference())
+    {}
+};
+
+template<class Base>
+void xml_unescape<Base>::drain_residue(const char * literal){
+    do{
+        if(* literal != * ++(this->base_reference()))
+            boost::serialization::throw_exception(
+                dataflow_exception(
+                    dataflow_exception::invalid_xml_escape_sequence
+                )
+            );
+    }
+    while('\0' != * ++literal);
+}
+
+// note key constraint on this function is that can't "look ahead" any
+// more than necessary into base iterator.  Doing so would alter the base
+// iterator refenence which would make subsequent iterator comparisons
+// incorrect and thereby break the composiblity of iterators.
+template<class Base>
+int xml_unescape<Base>::drain(){
+    int retval = * this->base_reference();
+    if('&' != retval){
+        return retval;
+    }
+    retval = * ++(this->base_reference());
+    switch(retval){
+    case 'l': // &lt;
+        drain_residue("t;");
+        retval = '<';
+        break;
+    case 'g': // &gt;
+        drain_residue("t;");
+        retval = '>';
+        break;
+    case 'a':
+        retval = * ++(this->base_reference());
+        switch(retval){
+        case 'p': // &apos;
+            drain_residue("os;");
+            retval = '\'';
+            break;
+        case 'm': // &amp;
+            drain_residue("p;");
+            retval = '&';
+            break;
+        }
+        break;
+    case 'q':
+        drain_residue("uot;");
+        retval = '"';
+        break;
+    }
+    return retval;
+}
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
diff --git a/ext/boost/archive/iterators/xml_unescape_exception.hpp b/ext/boost/archive/iterators/xml_unescape_exception.hpp
new file mode 100644
index 0000000000..a141737347
--- /dev/null
+++ b/ext/boost/archive/iterators/xml_unescape_exception.hpp
@@ -0,0 +1,49 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
+#define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_unescape_exception.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_EXCEPTIONS
+#include <exception>
+
+#include <cassert>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by xml_unescapes
+//
+class xml_unescape_exception : public std::exception
+{
+public:
+    xml_unescape_exception()
+    {}
+
+    virtual const char *what( ) const throw( )
+    {
+        return "xml contained un-recognized escape code";
+    }
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif //BOOST_NO_EXCEPTIONS
+#endif //BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
diff --git a/ext/boost/serialization/access.hpp b/ext/boost/serialization/access.hpp
new file mode 100644
index 0000000000..990f034e75
--- /dev/null
+++ b/ext/boost/serialization/access.hpp
@@ -0,0 +1,138 @@
+#ifndef BOOST_SERIALIZATION_ACCESS_HPP
+#define BOOST_SERIALIZATION_ACCESS_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// access.hpp: interface for serialization system.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+
+#include <boost/serialization/pfto.hpp>
+
+namespace boost {
+
+namespace archive {
+namespace detail {
+    template<class Archive, class T>
+    class iserializer;
+    template<class Archive, class T>
+    class oserializer;
+} // namespace detail
+} // namespace archive
+
+namespace serialization {
+
+// forward declarations
+template<class Archive, class T>
+inline void serialize_adl(Archive &, T &, const unsigned int);
+namespace detail {
+    template<class Archive, class T>
+    struct member_saver;
+    template<class Archive, class T>
+    struct member_loader;
+} // namespace detail
+
+// use an "accessor class so that we can use: 
+// "friend class boost::serialization::access;" 
+// in any serialized class to permit clean, safe access to private class members
+// by the serialization system
+
+class access {
+public:
+    // grant access to "real" serialization defaults
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+    template<class Archive, class T>
+    friend struct detail::member_saver;
+    template<class Archive, class T>
+    friend struct detail::member_loader;
+    template<class Archive, class T>
+    friend class archive::detail::iserializer;
+    template<class Archive, class T>
+    friend class archive::detail::oserializer;
+    template<class Archive, class T>
+    friend inline void serialize(
+        Archive & ar, 
+        T & t, 
+        const BOOST_PFTO unsigned int file_version
+    );
+    template<class Archive, class T>
+    friend inline void save_construct_data(
+        Archive & ar, 
+        const T * t, 
+        const BOOST_PFTO unsigned int file_version
+    );
+    template<class Archive, class T>
+    friend inline void load_construct_data(
+        Archive & ar, 
+        T * t, 
+        const BOOST_PFTO unsigned int file_version
+    );
+#endif
+
+    // pass calls to users's class implementation
+    template<class Archive, class T>
+    static void member_save(
+        Archive & ar, 
+        //const T & t,
+        T & t,
+        const unsigned int file_version
+    ){
+        t.save(ar, file_version);
+    }
+    template<class Archive, class T>
+    static void member_load(
+        Archive & ar, 
+        T & t,
+        const unsigned int file_version
+    ){
+        t.load(ar, file_version);
+    }
+    template<class Archive, class T>
+    static void serialize(
+        Archive & ar, 
+        T & t, 
+        const unsigned int file_version
+    ){
+        t.serialize(ar, file_version);
+    }
+    template<class T>
+    static void destroy( const T * t) // const appropriate here?
+    {
+        // the const business is an MSVC 6.0 hack that should be
+        // benign on everything else
+        delete const_cast<T *>(t);
+    }
+    template<class T>
+    static void construct(T * t){
+        // default is inplace invocation of default constructor
+        // Note the :: before the placement new. Required if the
+        // class doesn't have a class-specific placement new defined.
+        ::new(t)T;
+    }
+    template<class T, class U>
+    static T & cast_reference(U & u){
+        return static_cast<T &>(u);
+    }
+    template<class T, class U>
+    static T * cast_pointer(U * u){
+        return static_cast<T *>(u);
+    }
+};
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_ACCESS_HPP
diff --git a/ext/boost/serialization/array.hpp b/ext/boost/serialization/array.hpp
new file mode 100644
index 0000000000..b9dc32dad5
--- /dev/null
+++ b/ext/boost/serialization/array.hpp
@@ -0,0 +1,147 @@
+#ifndef BOOST_SERIALIZATION_ARRAY_HPP
+#define BOOST_SERIALIZATION_ARRAY_HPP
+
+// (C) Copyright 2005 Matthias Troyer and Dave Abrahams
+// Use, modification and distribution is subject to 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/serialization/nvp.hpp>
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/wrapper.hpp>
+#include <boost/mpl/always.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/array.hpp>
+#include <iostream>
+
+#include <cstddef> // std::size_t
+#include <cstddef>
+#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+namespace boost { namespace serialization {
+
+// traits to specify whether to use  an optimized array serialization
+
+#ifdef __BORLANDC__
+// workaround for Borland compiler
+template <class Archive>
+struct use_array_optimization {
+  template <class T> struct apply : boost::mpl::false_ {};
+};
+
+#else
+template <class Archive>
+struct use_array_optimization : boost::mpl::always<boost::mpl::false_> {};
+#endif
+
+template<class T>
+class array
+ : public wrapper_traits<array<T> >
+{
+public:    
+    typedef T value_type;
+    
+    array(value_type* t, std::size_t s) :
+        m_t(t),
+        m_element_count(s)
+    {}
+    
+    // default implementation
+    template<class Archive>
+    void serialize_optimized(Archive &ar, const unsigned int, mpl::false_ ) const
+    {
+      // default implemention does the loop
+      std::size_t c = count();
+      value_type * t = address();
+      while(0 < c--)
+            ar & boost::serialization::make_nvp("item", *t++);
+    }
+
+    // optimized implementation
+    template<class Archive>
+    void serialize_optimized(Archive &ar, const unsigned int version, mpl::true_ )
+    {
+      boost::serialization::split_member(ar, *this, version);
+    }
+
+    // default implementation
+    template<class Archive>
+    void save(Archive &ar, const unsigned int version) const
+    {
+      ar.save_array(*this,version);
+    }
+
+    // default implementation
+    template<class Archive>
+    void load(Archive &ar, const unsigned int version)
+    {
+      ar.load_array(*this,version);
+    }
+    
+    // default implementation
+    template<class Archive>
+    void serialize(Archive &ar, const unsigned int version)
+    {
+      typedef BOOST_DEDUCED_TYPENAME 
+          boost::serialization::use_array_optimization<Archive>::template apply<
+                    BOOST_DEDUCED_TYPENAME remove_const<T>::type 
+                >::type use_optimized;
+      serialize_optimized(ar,version,use_optimized());
+    }
+    
+    value_type* address() const
+    {
+      return m_t;
+    }
+
+    std::size_t count() const
+    {
+      return m_element_count;
+    }
+    
+private:
+    value_type* m_t;
+    std::size_t const m_element_count;
+};
+
+template<class T>
+inline
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+const
+#endif
+array<T> make_array( T* t, std::size_t s){
+    return array<T>(t, s);
+}
+
+template <class Archive, class T, std::size_t N>
+void serialize(Archive& ar, boost::array<T,N>& a, const unsigned int /* version */)
+{
+  ar & boost::serialization::make_nvp("elems",a.elems);
+}
+
+
+
+} } // end namespace boost::serialization
+
+#ifdef __BORLANDC__
+// ignore optimizations for Borland
+#define BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(Archive)      
+#else
+#define BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(Archive)           \
+namespace boost { namespace serialization {                           \
+template <> struct use_array_optimization<Archive> {                  \
+  template <class ValueType>                                          \
+  struct apply : boost::mpl::apply1<Archive::use_array_optimization   \
+      , BOOST_DEDUCED_TYPENAME boost::remove_const<ValueType>::type   \
+    >::type {};                                                       \
+}; }}
+#endif // __BORLANDC__
+
+#endif //BOOST_SERIALIZATION_ARRAY_HPP
diff --git a/ext/boost/serialization/assume_abstract.hpp b/ext/boost/serialization/assume_abstract.hpp
new file mode 100644
index 0000000000..a89cc44bd2
--- /dev/null
+++ b/ext/boost/serialization/assume_abstract.hpp
@@ -0,0 +1,59 @@
+#ifndef BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP
+#define BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// assume_abstract_class.hpp:
+
+// (C) Copyright 2008 Robert Ramey
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+// this is useful for compilers which don't support the boost::is_abstract
+
+#include <boost/type_traits/is_abstract.hpp>
+
+#ifndef BOOST_NO_IS_ABSTRACT
+
+// if there is an intrinsic is_abstract defined, we don't have to do anything
+#define BOOST_SERIALIZATION_ASSUME_ABSTRACT(T)
+
+// but forward to the "official" is_abstract
+namespace boost {
+namespace serialization {
+    template<class T>
+    struct is_abstract : boost::is_abstract<T> {} ;
+} // namespace serialization
+} // namespace boost
+
+#else
+// we have to "make" one
+
+namespace boost {
+namespace serialization {
+    template<class T>
+    struct is_abstract : boost::false_type {};
+} // namespace serialization
+} // namespace boost
+
+// define a macro to make explicit designation of this more transparent
+#define BOOST_SERIALIZATION_ASSUME_ABSTRACT(T)        \
+namespace boost {                                     \
+namespace serialization {                             \
+template<>                                            \
+struct is_abstract< T > : boost::true_type {};        \
+template<>                                            \
+struct is_abstract< const T > : boost::true_type {};  \
+}}                                                    \
+/**/
+
+#endif // BOOST_NO_IS_ABSTRACT
+
+#endif //BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP
diff --git a/ext/boost/serialization/base_object.hpp b/ext/boost/serialization/base_object.hpp
new file mode 100644
index 0000000000..b840d25e99
--- /dev/null
+++ b/ext/boost/serialization/base_object.hpp
@@ -0,0 +1,112 @@
+#ifndef BOOST_SERIALIZATION_BASE_OBJECT_HPP
+#define BOOST_SERIALIZATION_BASE_OBJECT_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// base_object.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+// if no archive headers have been included this is a no op
+// this is to permit BOOST_EXPORT etc to be included in a 
+// file declaration header
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/identity.hpp>
+
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/serialization/access.hpp>
+#include <boost/serialization/force_include.hpp>
+#include <boost/serialization/void_cast_fwd.hpp>
+
+namespace boost {
+namespace serialization {
+
+namespace detail
+{
+    // get the base type for a given derived type
+    // preserving the const-ness
+    template<class B, class D>
+    struct base_cast
+    {
+        typedef BOOST_DEDUCED_TYPENAME
+        mpl::if_<
+            is_const<D>,
+            const B,
+            B
+        >::type type;
+        BOOST_STATIC_ASSERT(is_const<type>::value == is_const<D>::value);
+    };
+
+    // only register void casts if the types are polymorphic
+    template<class Base, class Derived>
+    struct base_register
+    {
+        struct polymorphic {
+            static void const * invoke(){
+                Base const * const b = 0;
+                Derived const * const d = 0;
+                return & void_cast_register(d, b);
+            }
+        };
+        struct non_polymorphic {
+            static void const * invoke(){
+                return 0;
+            }
+        };
+        static void const * invoke(){
+            typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+                is_polymorphic<Base>,
+                mpl::identity<polymorphic>,
+                mpl::identity<non_polymorphic>
+            >::type type;
+            return type::invoke();
+        }
+    };
+
+} // namespace detail
+#if defined(__BORLANDC__) && __BORLANDC__ < 0x610
+template<class Base, class Derived>
+const Base & 
+base_object(const Derived & d)
+{
+    BOOST_STATIC_ASSERT(! is_pointer<Derived>::value);
+    detail::base_register<Base, Derived>::invoke();
+    return access::cast_reference<const Base, Derived>(d);
+}
+#else
+template<class Base, class Derived>
+BOOST_DEDUCED_TYPENAME detail::base_cast<Base, Derived>::type & 
+base_object(Derived &d)
+{
+    BOOST_STATIC_ASSERT(( is_base_and_derived<Base,Derived>::value));
+    BOOST_STATIC_ASSERT(! is_pointer<Derived>::value);
+    typedef BOOST_DEDUCED_TYPENAME detail::base_cast<Base, Derived>::type type;
+    detail::base_register<type, Derived>::invoke();
+    return access::cast_reference<type, Derived>(d);
+}
+#endif
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_BASE_OBJECT_HPP
diff --git a/ext/boost/serialization/binary_object.hpp b/ext/boost/serialization/binary_object.hpp
new file mode 100644
index 0000000000..1f49a4f9f8
--- /dev/null
+++ b/ext/boost/serialization/binary_object.hpp
@@ -0,0 +1,96 @@
+#ifndef BOOST_SERIALIZATION_BINARY_OBJECT_HPP
+#define BOOST_SERIALIZATION_BINARY_OBJECT_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// nvp.hpp: interface for serialization system.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <cassert>
+
+#include <cstddef> // std::size_t
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/preprocessor/stringize.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/wrapper.hpp>
+
+namespace boost {
+namespace serialization {
+
+struct binary_object {
+    /* const */ void * const m_t;
+    const std::size_t m_size;
+    template<class Archive>
+    void save(Archive & ar, const unsigned int /* file_version */) const {
+        ar.save_binary(m_t, m_size);
+    }
+    template<class Archive>
+    void load(Archive & ar, const unsigned int /* file_version */) const {
+        ar.load_binary(const_cast<void *>(m_t), m_size);
+    }
+    BOOST_SERIALIZATION_SPLIT_MEMBER()
+    binary_object(/* const */ void * const t, std::size_t size) :
+        m_t(t),
+        m_size(size)
+    {}
+    binary_object(const binary_object & rhs) :
+        m_t(rhs.m_t),
+        m_size(rhs.m_size)
+    {}
+};
+
+// just a little helper to support the convention that all serialization
+// wrappers follow the naming convention make_xxxxx
+inline 
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+const
+#endif
+binary_object 
+make_binary_object(/* const */ void * t, std::size_t size){
+    return binary_object(t, size);
+}
+
+// this is a wrapper
+
+template <>
+struct is_wrapper<binary_object>
+ : public mpl::true_
+{};
+
+} // namespace serialization
+} // boost
+
+// don't need versioning info for this type
+BOOST_CLASS_IMPLEMENTATION(
+    binary_object, 
+    boost::serialization::object_serializable
+)
+
+// don't track binary objects - usually they will be created on the stack
+// and tracking algorithm (which uses the object address) might get
+// confused.  note that these address will likely be members of some
+// other structure which itself is tracked, so as a practical matter
+// suppressing tracking shouldn't cause any redundancy.
+
+BOOST_CLASS_TRACKING(binary_object, boost::serialization::track_never) 
+
+#endif // BOOST_SERIALIZATION_BINARY_OBJECT_HPP
diff --git a/ext/boost/serialization/bitset.hpp b/ext/boost/serialization/bitset.hpp
new file mode 100644
index 0000000000..0e109ce29c
--- /dev/null
+++ b/ext/boost/serialization/bitset.hpp
@@ -0,0 +1,75 @@
+/*!
+ * \file      bitset.hpp
+ * \brief     Provides Boost.Serialization support for std::bitset
+ * \author    Brian Ravnsgaard Riis
+ * \author    Kenneth Riddile
+ * \date      16.09.2004, updated 04.03.2009
+ * \copyright 2004 Brian Ravnsgaard Riis
+ * \license   Boost Software License 1.0
+ */
+#ifndef BOOST_SERIALIZATION_BITSET_HPP
+#define BOOST_SERIALIZATION_BITSET_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <bitset>
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/string.hpp>
+#include <boost/serialization/nvp.hpp>
+
+namespace boost{
+namespace serialization{
+
+template <class Archive, std::size_t size>
+inline void save(
+    Archive & ar,
+    std::bitset<size> const & t,
+    const unsigned int /* version */
+){
+    const std::string bits = t.template to_string<
+        std::string::value_type,
+        std::string::traits_type,
+        std::string::allocator_type
+    >();
+    ar << BOOST_SERIALIZATION_NVP( bits );
+}
+
+template <class Archive, std::size_t size>
+inline void load(
+    Archive & ar,
+    std::bitset<size> & t,
+    const unsigned int /* version */
+){
+    std::string bits;
+    ar >> BOOST_SERIALIZATION_NVP( bits );
+    t = std::bitset<size>(bits);
+}
+
+template <class Archive, std::size_t size>
+inline void serialize(
+    Archive & ar,
+    std::bitset<size> & t,
+    const unsigned int version
+){
+    boost::serialization::split_free( ar, t, version );
+}
+
+// don't track bitsets since that would trigger tracking
+// all over the program - which probably would be a surprise.
+// also, tracking would be hard to implement since, we're
+// serialization a representation of the data rather than
+// the data itself.
+template <std::size_t size>
+struct tracking_level<std::bitset<size> >
+    : mpl::int_<track_never> {} ;
+
+} //serialization
+} //boost
+
+#endif // BOOST_SERIALIZATION_BITSET_HPP
diff --git a/ext/boost/serialization/collection_size_type.hpp b/ext/boost/serialization/collection_size_type.hpp
new file mode 100644
index 0000000000..b56f4d70f7
--- /dev/null
+++ b/ext/boost/serialization/collection_size_type.hpp
@@ -0,0 +1,20 @@
+#ifndef BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
+#define BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
+
+// (C) Copyright 2005 Matthias Troyer
+// Use, modification and distribution is subject to 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/serialization/strong_typedef.hpp>
+#include <boost/serialization/level.hpp>
+
+namespace boost { namespace serialization {
+
+BOOST_STRONG_TYPEDEF(std::size_t, collection_size_type)
+
+} } // end namespace boost::serialization
+
+BOOST_CLASS_IMPLEMENTATION(boost::serialization::collection_size_type, primitive_type)
+
+#endif //BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
diff --git a/ext/boost/serialization/collection_traits.hpp b/ext/boost/serialization/collection_traits.hpp
new file mode 100644
index 0000000000..568b807402
--- /dev/null
+++ b/ext/boost/serialization/collection_traits.hpp
@@ -0,0 +1,98 @@
+#ifndef BOOST_SERIALIZATION_COLLECTION_TRAITS_HPP
+#define BOOST_SERIALIZATION_COLLECTION_TRAITS_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// collection_traits.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+// This header assigns a level implemenation trait to a collection type
+// for all primitives.  It is needed so that archives which are meant to be
+// portable don't write class information in the archive.  Since, not all
+// compiles recognize the same set of primitive types, the possibility
+// exists for archives to be non-portable if class information for primitive
+// types is included.  This is addressed by the following macros.
+#include <boost/config.hpp>
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/cstdint.hpp>
+#include <climits> // ULONG_MAX
+#include <boost/serialization/level.hpp>
+
+#define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(T, C)          \
+template<>                                                          \
+struct implementation_level< C < T > > {                            \
+    typedef mpl::integral_c_tag tag;                                \
+    typedef mpl::int_<object_serializable> type;                    \
+    BOOST_STATIC_CONSTANT(int, value = object_serializable);        \
+};                                                                  \
+/**/
+
+#if defined(BOOST_NO_CWCHAR) || defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C)
+#else
+    #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C)   \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(wchar_t, C)        \
+    /**/
+#endif
+
+// determine if its necessary to handle (u)int64_t specifically
+// i.e. that its not a synonym for (unsigned) long
+// if there is no 64 bit int or if its the same as a long
+// we shouldn't define separate functions for int64 data types.
+#if defined(BOOST_NO_INT64_T)  
+     #define BOOST_NO_INTRINSIC_INT64_T  
+#else   
+    #if defined(ULLONG_MAX)  
+        #if(ULONG_MAX == 18446744073709551615ul) // 2**64 - 1  
+            #define BOOST_NO_INTRINSIC_INT64_T  
+        #endif  
+    #elif defined(ULONG_MAX)  
+        #if(ULONG_MAX != 0xffffffff && ULONG_MAX == 18446744073709551615ul) // 2**64 - 1  
+            #define BOOST_NO_INTRINSIC_INT64_T  
+        #endif  
+    #else   
+        #define BOOST_NO_INTRINSIC_INT64_T  
+    #endif  
+#endif  
+
+#if !defined(BOOST_NO_INTRINSIC_INT64_T)
+    #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C)    \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(boost::int64_t, C)  \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(boost::uint64_t, C) \
+    /**/
+#else
+    #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C)
+#endif
+
+#define BOOST_SERIALIZATION_COLLECTION_TRAITS(C)                     \
+    namespace boost { namespace serialization {                      \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(bool, C)            \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(char, C)            \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed char, C)     \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned char, C)   \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed int, C)      \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned int, C)    \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed long, C)     \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned long, C)   \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(float, C)           \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(double, C)          \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned short, C)  \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed short, C)    \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C)            \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C)            \
+    } }                                                              \
+    /**/
+
+#endif // BOOST_SERIALIZATION_COLLECTION_TRAITS
diff --git a/ext/boost/serialization/collections_load_imp.hpp b/ext/boost/serialization/collections_load_imp.hpp
new file mode 100644
index 0000000000..04e5051993
--- /dev/null
+++ b/ext/boost/serialization/collections_load_imp.hpp
@@ -0,0 +1,199 @@
+#ifndef  BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP
+#define BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER <= 1020)
+#  pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// collections_load_imp.hpp: serialization for loading stl collections
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+// helper function templates for serialization of collections
+
+#include <cassert>
+#include <cstddef> // size_t
+#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+#include <boost/detail/workaround.hpp>
+
+#include <boost/serialization/access.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/detail/stack_constructor.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+
+
+namespace boost{
+namespace serialization {
+namespace stl {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of serialization for STL containers
+//
+
+// sequential container input
+template<class Archive, class Container>
+struct archive_input_seq
+{
+    inline void operator()(
+        Archive &ar, 
+        Container &s, 
+        const unsigned int v
+    ){
+        typedef BOOST_DEDUCED_TYPENAME Container::value_type type;
+        detail::stack_construct<Archive, type> t(ar, v);
+        // borland fails silently w/o full namespace
+        ar >> boost::serialization::make_nvp("item", t.reference());
+        s.push_back(t.reference());
+        ar.reset_object_address(& s.back() , & t.reference());
+    }
+};
+
+// map input
+template<class Archive, class Container>
+struct archive_input_map
+{
+    inline void operator()(
+        Archive &ar, 
+        Container &s, 
+        const unsigned int v
+    ){
+        typedef BOOST_DEDUCED_TYPENAME Container::value_type type;
+        detail::stack_construct<Archive, type> t(ar, v);
+        // borland fails silently w/o full namespace
+        ar >> boost::serialization::make_nvp("item", t.reference());
+        std::pair<BOOST_DEDUCED_TYPENAME Container::const_iterator, bool> result = 
+            s.insert(t.reference());
+        // note: the following presumes that the map::value_type was NOT tracked
+        // in the archive.  This is the usual case, but here there is no way
+        // to determine that.  
+        if(result.second){
+            ar.reset_object_address(
+                & (result.first->second),
+                & t.reference().second
+            );
+        }
+    }
+};
+
+// multimap input
+template<class Archive, class Container>
+struct archive_input_multimap
+{
+    inline void operator()(
+        Archive &ar, 
+        Container &s, 
+        const unsigned int v
+    ){
+        typedef BOOST_DEDUCED_TYPENAME Container::value_type type;
+        detail::stack_construct<Archive, type> t(ar, v);
+        // borland fails silently w/o full namespace
+        ar >> boost::serialization::make_nvp("item", t.reference());
+        BOOST_DEDUCED_TYPENAME Container::const_iterator result 
+            = s.insert(t.reference());
+        // note: the following presumes that the map::value_type was NOT tracked
+        // in the archive.  This is the usual case, but here there is no way
+        // to determine that.  
+        ar.reset_object_address(
+            & result->second,
+            & t.reference()
+        );
+    }
+};
+
+// set input
+template<class Archive, class Container>
+struct archive_input_set
+{
+    inline void operator()(
+        Archive &ar, 
+        Container &s, 
+        const unsigned int v
+    ){
+        typedef BOOST_DEDUCED_TYPENAME Container::value_type type;
+        detail::stack_construct<Archive, type> t(ar, v);
+        // borland fails silently w/o full namespace
+        ar >> boost::serialization::make_nvp("item", t.reference());
+        std::pair<BOOST_DEDUCED_TYPENAME Container::const_iterator, bool> result = 
+            s.insert(t.reference());
+        if(result.second)
+            ar.reset_object_address(& (* result.first), & t.reference());
+    }
+};
+
+// multiset input
+template<class Archive, class Container>
+struct archive_input_multiset
+{
+    inline void operator()(
+        Archive &ar, 
+        Container &s, 
+        const unsigned int v
+    ){
+        typedef BOOST_DEDUCED_TYPENAME Container::value_type type;
+        detail::stack_construct<Archive, type> t(ar, v);
+        // borland fails silently w/o full namespace
+        ar >> boost::serialization::make_nvp("item", t.reference());
+        BOOST_DEDUCED_TYPENAME Container::const_iterator result 
+            = s.insert(t.reference());
+        ar.reset_object_address(& (* result), & t.reference());
+    }
+};
+
+template<class Container>
+class reserve_imp
+{
+public:
+    void operator()(Container &s, std::size_t count) const {
+        s.reserve(count);
+    }
+};
+
+template<class Container>
+class no_reserve_imp
+{
+public:
+    void operator()(Container & /* s */, std::size_t /* count */) const{}
+};
+
+template<class Archive, class Container, class InputFunction, class R>
+inline void load_collection(Archive & ar, Container &s)
+{
+    s.clear();
+    // retrieve number of elements
+    collection_size_type count;
+    unsigned int item_version;
+    ar >> BOOST_SERIALIZATION_NVP(count);
+    if(3 < ar.get_library_version())
+        ar >> BOOST_SERIALIZATION_NVP(item_version);
+    else
+        item_version = 0;
+    R rx;
+    rx(s, count);
+    std::size_t c = count;
+    InputFunction ifunc;
+    while(c-- > 0){
+        ifunc(ar, s, item_version);
+    }
+}
+
+} // namespace stl 
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP
diff --git a/ext/boost/serialization/collections_save_imp.hpp b/ext/boost/serialization/collections_save_imp.hpp
new file mode 100644
index 0000000000..60580f65f1
--- /dev/null
+++ b/ext/boost/serialization/collections_save_imp.hpp
@@ -0,0 +1,68 @@
+#ifndef BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP
+#define BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// collections_save_imp.hpp: serialization for stl collections
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+// helper function templates for serialization of collections
+
+#include <boost/config.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+
+namespace boost{
+namespace serialization {
+namespace stl {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of serialization for STL containers
+//
+
+template<class Archive, class Container>
+inline void save_collection(Archive & ar, const Container &s)
+{
+    // record number of elements
+    collection_size_type const count(s.size());
+    ar <<  BOOST_SERIALIZATION_NVP(count);
+    // make sure the target type is registered so we can retrieve
+    // the version when we load
+    if(3 < ar.get_library_version()){
+        const unsigned int item_version = version<
+            BOOST_DEDUCED_TYPENAME Container::value_type
+        >::value;
+        ar << BOOST_SERIALIZATION_NVP(item_version);
+    }
+    BOOST_DEDUCED_TYPENAME Container::const_iterator it = s.begin();
+    std::size_t c=count;
+    while(c-- > 0){
+            // note borland emits a no-op without the explicit namespace
+            boost::serialization::save_construct_data_adl(
+                ar, 
+                &(*it), 
+                boost::serialization::version<
+                    BOOST_DEDUCED_TYPENAME Container::value_type
+                >::value
+            );
+        ar << boost::serialization::make_nvp("item", *it++);
+    }
+}
+
+} // namespace stl 
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP
diff --git a/ext/boost/serialization/complex.hpp b/ext/boost/serialization/complex.hpp
new file mode 100644
index 0000000000..125766fc07
--- /dev/null
+++ b/ext/boost/serialization/complex.hpp
@@ -0,0 +1,81 @@
+#ifndef  BOOST_SERIALIZATION_COMPLEX_HPP
+#define BOOST_SERIALIZATION_COMPLEX_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization/utility.hpp:
+// serialization for stl utility templates
+
+// (C) Copyright 2007 Matthias Troyer . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <complex>
+#include <boost/config.hpp>
+
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class T>
+inline void serialize(
+    Archive & ar,
+    std::complex<T> & t,
+    const unsigned int file_version 
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+template<class Archive, class T>
+inline void save(
+    Archive & ar,
+    std::complex<T> const & t,
+    const unsigned int /* file_version */
+){
+    const T re = t.real();
+    const T im = t.imag();
+    ar << boost::serialization::make_nvp("real", re);
+    ar << boost::serialization::make_nvp("imag", im);
+}
+
+template<class Archive, class T>
+inline void load(
+    Archive & ar,
+    std::complex<T>& t,
+    const unsigned int /* file_version */ 
+){
+    T re;
+    T im;
+    ar >> boost::serialization::make_nvp("real", re);
+    ar >> boost::serialization::make_nvp("imag", im);
+    t = std::complex<T>(re,im);
+}
+
+// specialization of serialization traits for complex
+template <class T>
+struct is_bitwise_serializable<std::complex<T> >
+    : public is_bitwise_serializable<T> {};
+
+template <class T>
+struct implementation_level<std::complex<T> >
+    : mpl::int_<object_serializable> {} ;
+
+// treat complex just like builtin arithmetic types for tracking
+template <class T>
+struct tracking_level<std::complex<T> >
+    : mpl::int_<track_never> {} ;
+
+} // serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_COMPLEX_HPP
diff --git a/ext/boost/serialization/config.hpp b/ext/boost/serialization/config.hpp
new file mode 100644
index 0000000000..4c4eb683f9
--- /dev/null
+++ b/ext/boost/serialization/config.hpp
@@ -0,0 +1,82 @@
+// note lack of include guards.  This is intentional
+
+//  config.hpp  ---------------------------------------------//
+
+//  (c) Copyright Robert Ramey 2004
+//  Use, modification, and distribution is subject to 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 library home page at http://www.boost.org/libs/serialization
+
+//----------------------------------------------------------------------------// 
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/preprocessor/facilities/empty.hpp>
+
+// note: this version incorporates the related code into the the 
+// the same library as BOOST_ARCHIVE.  This could change some day in the
+// future
+
+// if BOOST_SERIALIZATION_DECL is defined undefine it now:
+#ifdef BOOST_SERIALIZATION_DECL
+    #undef BOOST_SERIALIZATION_DECL
+#endif
+
+#ifdef BOOST_HAS_DECLSPEC // defined in config system
+// we need to import/export our code only if the user has specifically
+// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost
+// libraries to be dynamically linked, or BOOST_SERIALIZATION_DYN_LINK
+// if they want just this one to be dynamically liked:
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+    #if !defined(BOOST_DYN_LINK)
+        #define BOOST_DYN_LINK
+    #endif
+    // export if this is our own source, otherwise import:
+    #if defined(BOOST_SERIALIZATION_SOURCE)
+        #if defined(__BORLANDC__)
+            #define BOOST_SERIALIZATION_DECL(T) T __export
+        #else
+            #define BOOST_SERIALIZATION_DECL(T) __declspec(dllexport) T
+        #endif
+    #else
+        #if defined(__BORLANDC__)
+            #define BOOST_SERIALIZATION_DECL(T) T __import
+        #else
+            #define BOOST_SERIALIZATION_DECL(T) __declspec(dllimport) T
+        #endif
+    #endif // defined(BOOST_SERIALIZATION_SOURCE)
+#endif // defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+#endif // BOOST_HAS_DECLSPEC
+
+// if BOOST_SERIALIZATION_DECL isn't defined yet define it now:
+#ifndef BOOST_SERIALIZATION_DECL
+    #define BOOST_SERIALIZATION_DECL(T) T
+#endif
+
+//  enable automatic library variant selection  ------------------------------// 
+
+#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \
+&&  !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE)  \
+&&  !defined(BOOST_SERIALIZATION_SOURCE)
+    //
+    // Set the name of our library, this will get undef'ed by auto_link.hpp
+    // once it's done with it:
+    //
+    #define BOOST_LIB_NAME boost_serialization
+    //
+    // If we're importing code from a dll, then tell auto_link.hpp about it:
+    //
+    #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+    #  define BOOST_DYN_LINK
+    #endif
+    //
+    // And include the header that does the work:
+    //
+    #include <boost/config/auto_link.hpp>
+
+#endif  
diff --git a/ext/boost/serialization/deque.hpp b/ext/boost/serialization/deque.hpp
new file mode 100644
index 0000000000..340d5feedc
--- /dev/null
+++ b/ext/boost/serialization/deque.hpp
@@ -0,0 +1,75 @@
+#ifndef  BOOST_SERIALIZATION_DEQUE_HPP
+#define BOOST_SERIALIZATION_DEQUE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// deque.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <deque>
+
+#include <boost/config.hpp>
+
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class U, class Allocator>
+inline void save(
+    Archive & ar,
+    const std::deque<U, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    boost::serialization::stl::save_collection<
+        Archive, std::deque<U, Allocator> 
+    >(ar, t);
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+    Archive & ar,
+    std::deque<U, Allocator> &t,
+    const unsigned int /*file_version*/
+){
+    boost::serialization::stl::load_collection<
+        Archive,
+        std::deque<U, Allocator>,
+        boost::serialization::stl::archive_input_seq<
+        Archive, std::deque<U, Allocator> 
+        >,
+        boost::serialization::stl::no_reserve_imp<std::deque<U, Allocator> >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U, class Allocator>
+inline void serialize(
+    Archive & ar,
+    std::deque<U, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(std::deque)
+
+#endif // BOOST_SERIALIZATION_DEQUE_HPP
diff --git a/ext/boost/serialization/detail/get_data.hpp b/ext/boost/serialization/detail/get_data.hpp
new file mode 100644
index 0000000000..0e9c190295
--- /dev/null
+++ b/ext/boost/serialization/detail/get_data.hpp
@@ -0,0 +1,55 @@
+// (C) Copyright 2005 Matthias Troyer 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#ifndef BOOST_SERIALIZATION_DETAIL_GET_DATA_HPP
+#define BOOST_SERIALIZATION_DETAIL_GET_DATA_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+#define STD _STLP_STD
+#else
+#define STD std
+#endif
+
+
+#include <vector>
+#include <valarray>
+
+namespace boost { namespace serialization { namespace detail {
+
+template <class T, class Allocator>
+T* get_data(STD::vector<T,Allocator>& v)
+{
+  return v.empty() ? 0 : &(v[0]);
+}
+
+template <class T, class Allocator>
+T* get_data(STD::vector<T,Allocator> const & v)
+{
+  return get_data(const_cast<STD::vector<T,Allocator>&>(v));
+}
+
+
+template <class T>
+T* get_data(STD::valarray<T>& v)
+{
+  return v.size()==0 ? 0 : &(v[0]);
+}
+
+template <class T>
+const T* get_data(STD::valarray<T> const& v)
+{
+  return get_data(const_cast<STD::valarray<T>&>(v));
+}
+
+} } } //namespace boost::serialization::detail
+
+#endif // BOOST_SERIALIZATION_DETAIL_GET_DATA_HPP
diff --git a/ext/boost/serialization/detail/shared_count_132.hpp b/ext/boost/serialization/detail/shared_count_132.hpp
new file mode 100644
index 0000000000..0665e8749d
--- /dev/null
+++ b/ext/boost/serialization/detail/shared_count_132.hpp
@@ -0,0 +1,569 @@
+#ifndef BOOST_DETAIL_SHARED_COUNT_132_HPP_INCLUDED
+#define BOOST_DETAIL_SHARED_COUNT_132_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.
+//
+// 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/serialization/throw_exception.hpp>
+#include <boost/detail/lightweight_mutex.hpp>
+
+#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+#include <boost/detail/quick_allocator.hpp>
+#endif
+
+#include <memory>           // std::auto_ptr, std::allocator
+#include <functional>       // std::less
+#include <exception>        // std::exception
+#include <new>              // std::bad_alloc
+#include <typeinfo>         // std::type_info in get_deleter
+#include <cstddef>          // std::size_t
+
+#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#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_132 {
+
+// Debug hooks
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+void sp_scalar_constructor_hook(void * px, std::size_t size, void * pn);
+void sp_array_constructor_hook(void * px);
+void sp_scalar_destructor_hook(void * px, std::size_t size, void * pn);
+void sp_array_destructor_hook(void * px);
+
+#endif
+
+
+// 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 bad_weak_ptr
+// 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 bad_weak_ptr: public std::exception
+{
+public:
+
+    virtual char const * what() const throw()
+    {
+        return "boost::bad_weak_ptr";
+    }
+};
+
+#if defined(__BORLANDC__) && __BORLANDC__ == 0x551
+# pragma option pop
+#endif
+
+namespace detail{
+
+class sp_counted_base
+{
+//private:
+
+    typedef boost::detail::lightweight_mutex mutex_type;
+
+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
+
+    // destruct() is called when weak_count_ drops to zero.
+
+    virtual void destruct() // nothrow
+    {
+        delete this;
+    }
+
+    virtual void * get_deleter(std::type_info const & ti) = 0;
+
+    void add_ref_copy()
+    {
+#if defined(BOOST_HAS_THREADS)
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        ++use_count_;
+    }
+
+    void add_ref_lock()
+    {
+#if defined(BOOST_HAS_THREADS)
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        if(use_count_ == 0) boost::serialization::throw_exception(bad_weak_ptr());
+        ++use_count_;
+    }
+
+    void release() // nothrow
+    {
+        {
+#if defined(BOOST_HAS_THREADS)
+            mutex_type::scoped_lock lock(mtx_);
+#endif
+            long new_use_count = --use_count_;
+
+            if(new_use_count != 0) return;
+        }
+
+        dispose();
+        weak_release();
+    }
+
+    void weak_add_ref() // nothrow
+    {
+#if defined(BOOST_HAS_THREADS)
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        ++weak_count_;
+    }
+
+    void weak_release() // nothrow
+    {
+        long new_weak_count;
+
+        {
+#if defined(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
+    {
+#if defined(BOOST_HAS_THREADS)
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        return use_count_;
+    }
+
+//private:
+public:
+    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)
+
+#if defined(BOOST_HAS_THREADS) || defined(BOOST_LWM_WIN32)
+    mutable mutex_type mtx_;
+#endif
+};
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+template<class T> void cbi_call_constructor_hook(sp_counted_base * pn, T * px, checked_deleter<T> const &, int)
+{
+    boost::sp_scalar_constructor_hook(px, sizeof(T), pn);
+}
+
+template<class T> void cbi_call_constructor_hook(sp_counted_base *, T * px, checked_array_deleter<T> const &, int)
+{
+    boost::sp_array_constructor_hook(px);
+}
+
+template<class P, class D> void cbi_call_constructor_hook(sp_counted_base *, P const &, D const &, long)
+{
+}
+
+template<class T> void cbi_call_destructor_hook(sp_counted_base * pn, T * px, checked_deleter<T> const &, int)
+{
+    boost::sp_scalar_destructor_hook(px, sizeof(T), pn);
+}
+
+template<class T> void cbi_call_destructor_hook(sp_counted_base *, T * px, checked_array_deleter<T> const &, int)
+{
+    boost::sp_array_destructor_hook(px);
+}
+
+template<class P, class D> void cbi_call_destructor_hook(sp_counted_base *, P const &, D const &, long)
+{
+}
+
+#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_base_impl: public sp_counted_base
+{
+//private:
+public:
+    P ptr; // copy constructor must not throw
+    D del; // copy constructor must not throw
+
+    sp_counted_base_impl(sp_counted_base_impl const &);
+    sp_counted_base_impl & operator= (sp_counted_base_impl const &);
+
+    typedef sp_counted_base_impl<P, D> this_type;
+
+public:
+
+    // pre: initial_use_count <= initial_weak_count, d(p) must not throw
+
+    sp_counted_base_impl(P p, D d): ptr(p), del(d)
+    {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        detail::cbi_call_constructor_hook(this, p, d, 0);
+#endif
+    }
+
+    virtual void dispose() // nothrow
+    {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        detail::cbi_call_destructor_hook(this, ptr, del, 0);
+#endif
+        del(ptr);
+    }
+
+    virtual void * get_deleter(std::type_info const & ti)
+    {
+        return ti == typeid(D)? &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 boost::detail::quick_allocator<this_type>::alloc();
+    }
+
+    void operator delete(void * p)
+    {
+        boost::detail::quick_allocator<this_type>::dealloc(p);
+    }
+
+#endif
+};
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+int const shared_count_id = 0x2C35F101;
+int const   weak_count_id = 0x298C38A4;
+
+#endif
+
+class weak_count;
+
+class shared_count
+{
+//private:
+public:
+    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 P, class D> shared_count(P p, D d): pi_(0)
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+#ifndef BOOST_NO_EXCEPTIONS
+
+        try
+        {
+            pi_ = new sp_counted_base_impl<P, D>(p, d);
+        }
+        catch(...)
+        {
+            d(p); // delete p
+            throw;
+        }
+
+#else
+
+        pi_ = new sp_counted_base_impl<P, D>(p, d);
+
+        if(pi_ == 0)
+        {
+            d(p); // delete p
+            boost::serialization::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_base_impl<
+            Y *, 
+            boost::checked_deleter<Y>
+        >(r.get(), boost::checked_deleter<Y>()))
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#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();
+    }
+
+    explicit shared_count(weak_count const & r); // throws bad_weak_ptr 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;
+    }
+
+    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(std::type_info const & ti) const
+    {
+        return pi_? pi_->get_deleter(ti): 0;
+    }
+};
+
+#ifdef __CODEGUARD__
+# pragma option pop
+#endif
+
+
+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_(shared_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_(shared_count_id)
+#endif
+    {
+        if(pi_ != 0) pi_->weak_add_ref();
+    }
+
+    ~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 != 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 != 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;
+    }
+
+    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();
+    }
+    else
+    {
+        boost::serialization::throw_exception(bad_weak_ptr());
+    }
+}
+
+} // namespace detail
+
+} // namespace boost
+
+BOOST_SERIALIZATION_ASSUME_ABSTRACT(boost_132::detail::sp_counted_base)
+
+#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
diff --git a/ext/boost/serialization/detail/shared_ptr_132.hpp b/ext/boost/serialization/detail/shared_ptr_132.hpp
new file mode 100644
index 0000000000..bd5355d0ca
--- /dev/null
+++ b/ext/boost/serialization/detail/shared_ptr_132.hpp
@@ -0,0 +1,478 @@
+#ifndef BOOST_SHARED_PTR_132_HPP_INCLUDED
+#define BOOST_SHARED_PTR_132_HPP_INCLUDED
+
+//
+//  shared_ptr.hpp
+//
+//  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
+//  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/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/serialization/detail/shared_ptr_nmt_132.hpp>
+#else
+
+#include <boost/assert.hpp>
+#include <boost/checked_delete.hpp>
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/serialization/access.hpp>
+#include <boost/serialization/detail/shared_count_132.hpp>
+
+#include <memory>               // for std::auto_ptr
+#include <algorithm>            // for std::swap
+#include <functional>           // for std::less
+#include <typeinfo>             // for std::bad_cast
+#include <iosfwd>               // for std::basic_ostream
+
+#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_132 {
+
+template<class T> class weak_ptr;
+template<class T> class enable_shared_from_this;
+
+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 T, class Y> void sp_enable_shared_from_this( shared_count const & pn, enable_shared_from_this<T> const * pe, Y const * px )
+{
+    if(pe != 0) pe->_internal_weak_this._internal_assign(const_cast<Y*>(px), pn);
+}
+
+inline void sp_enable_shared_from_this( shared_count const & /*pn*/, ... )
+{
+}
+
+} // 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 BOOST_DEDUCED_TYPENAME detail::shared_ptr_traits<T>::reference reference;
+
+    shared_ptr(): px(0), pn() // never throws in 1.30+
+    {
+    }
+
+#if BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x564) )
+    template<class Y>
+    explicit shared_ptr(Y * p): px(p), pn(p, boost::checked_deleter<Y>()) // Y must be complete
+#else
+    template<class Y>
+    explicit shared_ptr(Y * p): px(p), pn(p, boost::checked_deleter<Y>()) // Y must be complete
+#endif
+    {
+        detail::sp_enable_shared_from_this( pn, 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)
+    {
+        detail::sp_enable_shared_from_this( pn, p, p );
+    }
+
+//  generated copy constructor, assignment, destructor are fine...
+
+//  except that Borland C++ has a bug, and g++ with -Wsynth warns
+#if defined(__BORLANDC__) || defined(__GNUC__)
+
+    shared_ptr & operator=(shared_ptr const & r) // never throws
+    {
+        px = r.px;
+        pn = r.pn; // shared_count::op= doesn't throw
+        return *this;
+    }
+
+#endif
+
+    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(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
+    {
+    }
+
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
+    {
+    }
+
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn)
+    {
+    }
+
+    template<class 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<class 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::serialization::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 = detail::shared_count(r);
+        detail::sp_enable_shared_from_this( pn, tmp, tmp );
+    }
+
+#endif
+
+#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
+
+    template<class 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<class Y>
+    shared_ptr & operator=(std::auto_ptr<Y> & r)
+    {
+        this_type(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);
+    }
+
+    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"
+
+#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
+
+    operator bool () const
+    {
+        return px != 0;
+    }
+
+#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+    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;
+    }
+
+    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(std::type_info const & ti) const
+    {
+        return pn.get_deleter(ti);
+    }
+
+// 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
+public: // for serialization
+    T * px;                     // contained pointer
+    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, 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, 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, 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, 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, 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, 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(__GNUC__) &&  (__GNUC__ < 3)
+
+template<class Y> std::ostream & operator<< (std::ostream & os, shared_ptr<Y> const & p)
+{
+    os << p.get();
+    return os;
+}
+
+#else
+
+# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, <= 1200 && __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
+
+// get_deleter (experimental)
+
+#if (defined(__GNUC__) &&  (__GNUC__ < 3)) || (defined(__EDG_VERSION__) && (__EDG_VERSION__ <= 238))
+
+// g++ 2.9x doesn't allow static_cast<X const *>(void *)
+// apparently EDG 2.38 also doesn't accept it
+
+template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
+{
+    void const * q = p._internal_get_deleter(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(typeid(D)));
+}
+
+#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_SHARED_PTR_132_HPP_INCLUDED
diff --git a/ext/boost/serialization/detail/shared_ptr_nmt_132.hpp b/ext/boost/serialization/detail/shared_ptr_nmt_132.hpp
new file mode 100644
index 0000000000..c73e98128e
--- /dev/null
+++ b/ext/boost/serialization/detail/shared_ptr_nmt_132.hpp
@@ -0,0 +1,182 @@
+#ifndef BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
+#define BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
+
+//
+//  detail/shared_ptr_nmt.hpp - shared_ptr.hpp without member templates
+//
+//  (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_ptr.htm for documentation.
+//
+
+#include <boost/assert.hpp>
+#include <boost/checked_delete.hpp>
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/detail/atomic_count.hpp>
+
+#ifndef BOOST_NO_AUTO_PTR
+# include <memory>          // for std::auto_ptr
+#endif
+
+#include <algorithm>        // for std::swap
+#include <functional>       // for std::less
+#include <new>              // for std::bad_alloc
+
+namespace boost
+{
+
+template<class T> class shared_ptr
+{
+private:
+
+    typedef detail::atomic_count count_type;
+
+public:
+
+    typedef T element_type;
+    typedef T value_type;
+
+    explicit shared_ptr(T * p = 0): px(p)
+    {
+#ifndef BOOST_NO_EXCEPTIONS
+
+        try  // prevent leak if new throws
+        {
+            pn = new count_type(1);
+        }
+        catch(...)
+        {
+            boost::checked_delete(p);
+            throw;
+        }
+
+#else
+
+        pn = new count_type(1);
+
+        if(pn == 0)
+        {
+            boost::checked_delete(p);
+            boost::serialization::throw_exception(std::bad_alloc());
+        }
+
+#endif
+    }
+
+    ~shared_ptr()
+    {
+        if(--*pn == 0)
+        {
+            boost::checked_delete(px);
+            delete pn;
+        }
+    }
+
+    shared_ptr(shared_ptr const & r): px(r.px)  // never throws
+    {
+        pn = r.pn;
+        ++*pn;
+    }
+
+    shared_ptr & operator=(shared_ptr const & r)
+    {
+        shared_ptr(r).swap(*this);
+        return *this;
+    }
+
+#ifndef BOOST_NO_AUTO_PTR
+
+    explicit shared_ptr(std::auto_ptr<T> & r)
+    { 
+        pn = new count_type(1); // may throw
+        px = r.release(); // fix: moved here to stop leak if new throws
+    } 
+
+    shared_ptr & operator=(std::auto_ptr<T> & r)
+    {
+        shared_ptr(r).swap(*this);
+        return *this;
+    }
+
+#endif
+
+    void reset(T * p = 0)
+    {
+        BOOST_ASSERT(p == 0 || p != px);
+        shared_ptr(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;
+    }
+
+    long use_count() const  // never throws
+    {
+        return *pn;
+    }
+
+    bool unique() const  // never throws
+    {
+        return *pn == 1;
+    }
+    
+    void swap(shared_ptr<T> & other)  // never throws
+    {
+        std::swap(px, other.px);
+        std::swap(pn, other.pn);
+    }
+
+private:
+
+    T * px;            // contained pointer
+    count_type * pn;   // ptr to reference counter
+};
+
+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();
+}
+
+template<class T> inline bool operator<(shared_ptr<T> const & a, shared_ptr<T> const & b)
+{
+    return std::less<T*>()(a.get(), b.get());
+}
+
+template<class T> void swap(shared_ptr<T> & a, shared_ptr<T> & b)
+{
+    a.swap(b);
+}
+
+// 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();
+}
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
diff --git a/ext/boost/serialization/detail/stack_constructor.hpp b/ext/boost/serialization/detail/stack_constructor.hpp
new file mode 100644
index 0000000000..de623b0d4f
--- /dev/null
+++ b/ext/boost/serialization/detail/stack_constructor.hpp
@@ -0,0 +1,73 @@
+#ifndef  BOOST_SERIALIZATION_DETAIL_STACH_CONSTRUCTOR_HPP
+#define BOOST_SERIALIZATION_DETAIL_STACH_CONSTRUCTOR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER <= 1020)
+#  pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// collections_load_imp.hpp: serialization for loading stl collections
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <boost/aligned_storage.hpp>
+
+namespace boost{
+namespace serialization {
+namespace detail {
+
+// reserve space on stack for an object of type T without actually
+// construction such an object
+template<typename T > 
+struct stack_allocate
+{
+    T * address() {
+        return static_cast<T*>(storage_.address()); 
+    }
+    T & reference() {
+        return * address();
+    }
+private:
+    typedef BOOST_DEDUCED_TYPENAME boost::aligned_storage<
+        sizeof(T), 
+        #if BOOST_WORKAROUND(__BORLANDC__,BOOST_TESTED_AT(0x560))
+            8
+        #else
+            boost::alignment_of<T>::value
+        #endif
+    > type;
+    type storage_;
+};
+
+// construct element on the stack
+template<class Archive, class T>
+struct stack_construct : public stack_allocate<T>
+{
+    stack_construct(Archive & ar, const unsigned int version){
+        // note borland emits a no-op without the explicit namespace
+        boost::serialization::load_construct_data_adl(
+            ar, 
+            this->address(), 
+            version
+        );
+    }
+    ~stack_construct(){
+        this->address()->~T(); // undo load_construct_data above
+    }
+};
+
+} // detail
+} // serializaition
+} // boost
+
+#endif //  BOOST_SERIALIZATION_DETAIL_STACH_CONSTRUCTOR_HPP
diff --git a/ext/boost/serialization/ephemeral.hpp b/ext/boost/serialization/ephemeral.hpp
new file mode 100644
index 0000000000..f559bec99f
--- /dev/null
+++ b/ext/boost/serialization/ephemeral.hpp
@@ -0,0 +1,80 @@
+#ifndef BOOST_SERIALIZATION_EPHEMERAL_HPP
+#define BOOST_SERIALIZATION_EPHEMERAL_HPP
+
+// MS compatible compilers support 
+#pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// ephemeral_object.hpp: interface for serialization system.
+
+// (C) Copyright 2007 Matthias Troyer. 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <utility>
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+// supress noise
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/base_object.hpp>
+#include <boost/serialization/traits.hpp>
+#include <boost/serialization/wrapper.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<class T>
+struct ephemeral_object : 
+    public wrapper_traits<ephemeral_object<T> >
+{
+    explicit ephemeral_object(T& t) :
+        val(t)
+    {}
+
+    T & value() const {
+        return val;
+    }
+
+    const T & const_value() const {
+        return val;
+    }
+
+    template<class Archive>
+    void serialize(Archive &ar, const unsigned int) const
+    {
+       ar & val;
+    }
+
+private:
+    T & val;
+};
+
+template<class T>
+inline
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+const
+#endif
+ephemeral_object<T> ephemeral(const char * name, T & t){
+    return ephemeral_object<T>(name, t);
+}
+
+} // seralization
+} // boost
+
+#endif // BOOST_SERIALIZATION_EPHEMERAL_HPP
diff --git a/ext/boost/serialization/export.hpp b/ext/boost/serialization/export.hpp
new file mode 100644
index 0000000000..b043f41590
--- /dev/null
+++ b/ext/boost/serialization/export.hpp
@@ -0,0 +1,218 @@
+#ifndef BOOST_SERIALIZATION_EXPORT_HPP
+#define BOOST_SERIALIZATION_EXPORT_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// export.hpp: set traits of classes to be serialized
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+// (C) Copyright 2006 David Abrahams - http://www.boost.org.
+// implementation of class export functionality.  This is an alternative to
+// "forward declaration" method to provoke instantiation of derived classes
+// that are to be serialized through pointers.
+
+#include <utility>
+#include <cstddef> // NULL
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/preprocessor/stringize.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+
+#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO   
+    #include <boost/serialization/extended_type_info_typeid.hpp>   
+#endif 
+#include <boost/serialization/static_warning.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+#include <boost/serialization/assume_abstract.hpp>
+#include <boost/serialization/force_include.hpp>
+#include <boost/serialization/singleton.hpp>
+
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/bool.hpp>
+
+#include <iostream>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class basic_pointer_iserializer;
+class basic_pointer_oserializer;
+
+template<class Archive, class T>
+class pointer_iserializer;
+template<class Archive, class T>
+class pointer_oserializer;
+
+template <class Archive, class Serializable>
+struct export_impl
+{
+    static const basic_pointer_iserializer &
+    enable_load(mpl::true_){
+        return boost::serialization::singleton<
+            pointer_iserializer<Archive, Serializable> 
+        >::get_const_instance();
+    }
+
+    static const basic_pointer_oserializer &
+    enable_save(mpl::true_){
+        return boost::serialization::singleton<
+            pointer_oserializer<Archive, Serializable> 
+        >::get_const_instance();
+    }
+    inline static void enable_load(mpl::false_) {}
+    inline static void enable_save(mpl::false_) {}
+};
+
+// On many platforms, naming a specialization of this template is
+// enough to cause its argument to be instantiated.
+template <void(*)()>
+struct instantiate_function {};
+
+template <class Archive, class Serializable>
+struct ptr_serialization_support
+{
+# if defined(BOOST_MSVC) || defined(__SUNPRO_CC)
+    virtual BOOST_DLLEXPORT void instantiate() BOOST_USED;
+# elif defined(__BORLANDC__)   
+    static BOOST_DLLEXPORT void instantiate() BOOST_USED;
+    enum { x = sizeof(instantiate(),3) };
+# else
+    static BOOST_DLLEXPORT void instantiate() BOOST_USED;
+    typedef instantiate_function<
+        &ptr_serialization_support::instantiate
+    > x;
+# endif
+};
+
+template <class Archive, class Serializable>
+BOOST_DLLEXPORT void 
+ptr_serialization_support<Archive,Serializable>::instantiate()
+{
+    export_impl<Archive,Serializable>::enable_save(
+        #if ! defined(__BORLANDC__)
+        BOOST_DEDUCED_TYPENAME 
+        #endif
+        Archive::is_saving()
+    );
+
+    export_impl<Archive,Serializable>::enable_load(
+        #if ! defined(__BORLANDC__)
+        BOOST_DEDUCED_TYPENAME 
+        #endif
+        Archive::is_loading()
+    );
+}
+
+namespace {
+
+template<class T>
+struct guid_initializer
+{  
+    const guid_initializer & export_guid(char const* /* key */, mpl::false_){
+        // generates the statically-initialized objects whose constructors
+        // register the information allowing serialization of T objects
+        // through pointers to their base classes.
+        instantiate_ptr_serialization((T*)0, 0, adl_tag());
+        return *this;
+    }
+    const guid_initializer & export_guid(char const* /*key*/, mpl::true_){
+        return *this;
+    }
+    const guid_initializer & export_guid(char const* key){
+        BOOST_STATIC_WARNING(boost::is_polymorphic<T>::value);
+        assert(NULL != key);
+        boost::serialization::singleton<
+            BOOST_DEDUCED_TYPENAME 
+            boost::serialization::type_info_implementation<T>::type
+        >::get_mutable_instance().key_register(key);
+        // note: exporting an abstract base class will have no effect
+        // and cannot be used to instantitiate serialization code
+        // (one might be using this in a DLL to instantiate code)
+        //BOOST_STATIC_WARNING(! boost::serialization::is_abstract<T>::value);
+        return export_guid(key, boost::serialization::is_abstract<T>());
+    }
+};
+
+template<typename T>
+struct init_guid;
+
+} // anonymous
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#define BOOST_CLASS_EXPORT_GUID(T, K)                                  \
+    namespace boost {                                                  \
+    namespace archive {                                                \
+    namespace detail {                                                 \
+    namespace {                                                        \
+    template<>                                                         \
+    struct init_guid< T > {                                            \
+        static ::boost::archive::detail::guid_initializer< T > const   \
+            & guid_initializer;                                        \
+    };                                                                 \
+    ::boost::archive::detail::guid_initializer< T > const &            \
+        ::boost::archive::detail::init_guid< T >::guid_initializer =   \
+           ::boost::serialization::singleton<                          \
+               ::boost::archive::detail::guid_initializer< T >         \
+           >::get_mutable_instance().export_guid(K);                   \
+    }}}}                                                                \
+/**/
+
+#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+
+// CodeWarrior fails to construct static members of class templates
+// when they are instantiated from within templates, so on that
+// compiler we ask users to specifically register base/derived class
+// relationships for exported classes.  On all other compilers, use of
+// this macro is entirely optional.
+# define BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED(Base,Derived)                  \
+namespace {                                                                         \
+  static int BOOST_PP_CAT(boost_serialization_mwerks_init_, __LINE__) =             \
+  (::boost::archive::detail::instantiate_ptr_serialization((Derived*)0,0), 3);      \
+  static int BOOST_PP_CAT(boost_serialization_mwerks_init2_, __LINE__) = (          \
+      ::boost::serialization::void_cast_register((Derived*)0,(Base*)0)              \
+    , 3);                                                                           \
+}
+
+#else
+
+# define BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED(Base,Derived)
+
+#endif 
+
+// check for unnecessary export.  T isn't polymorphic so there is no
+// need to export it.
+#define BOOST_CLASS_EXPORT_CHECK(T)                              \
+    BOOST_STATIC_WARNING(                                        \
+        boost::is_polymorphic<U>::value                          \
+    );                                                           \
+    /**/
+
+// the default exportable class identifier is the class name
+// the default list of archives types for which code id generated
+// are the originally included with this serialization system
+#define BOOST_CLASS_EXPORT(T)                   \
+    BOOST_CLASS_EXPORT_GUID(                    \
+        T,                                      \
+        BOOST_PP_STRINGIZE(T)                   \
+    )                                           \
+    /**/
+
+#endif // BOOST_SERIALIZATION_EXPORT_HPP
+
diff --git a/ext/boost/serialization/extended_type_info.hpp b/ext/boost/serialization/extended_type_info.hpp
new file mode 100644
index 0000000000..6becfdf876
--- /dev/null
+++ b/ext/boost/serialization/extended_type_info.hpp
@@ -0,0 +1,99 @@
+#ifndef BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP
+#define BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// extended_type_info.hpp: interface for portable version of type_info
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+// for now, extended type info is part of the serialization libraries
+// this could change in the future.
+#include <cstdarg>
+#include <cassert>
+#include <cstddef> // NULL
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/serialization/config.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+
+#include <boost/config/abi_prefix.hpp> // must be the last header
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4251 4231 4660 4275)
+#endif
+
+#define BOOST_SERIALIZATION_MAX_KEY_SIZE 128
+
+namespace boost { 
+namespace serialization {
+class BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY()) extended_type_info :
+    private boost::noncopyable
+{
+private: 
+    boost::shared_ptr<const extended_type_info> m_this;
+
+    // used to uniquely identify the type of class derived from this one
+    // so that different derivations of this class can be simultaneously
+    // included in implementation of sets and maps.
+    const unsigned int m_type_info_key;
+    virtual bool is_less_than(const extended_type_info & /*rhs*/) const = 0;
+    virtual bool is_equal(const extended_type_info & /*rhs*/) const = 0;
+    void key_unregister();
+protected:
+    const char * m_key;
+    // this class can't be used as is. It's just the 
+    // common functionality for all type_info replacement
+    // systems.  Hence, make these protected
+    extended_type_info(const unsigned int type_info_key = 0);
+    // account for bogus gcc warning
+    #if defined(__GNUC__)
+    virtual
+    #endif
+    ~extended_type_info();
+public:
+    const char * get_key() const {
+        return m_key;
+    }
+    void key_register(const char *key);
+    bool operator<(const extended_type_info &rhs) const;
+    bool operator==(const extended_type_info &rhs) const;
+    bool operator!=(const extended_type_info &rhs) const {
+        return !(operator==(rhs));
+    }
+    boost::weak_ptr<const extended_type_info>
+    get_weak_ptr() const {
+        return m_this;
+    }
+    static const extended_type_info * find(const char *key);
+    // for plugins
+    virtual void * construct(unsigned int /*count*/ = 0, ...) const {
+        assert(false); // must be implemented if used
+        return NULL;
+    };
+    virtual void destroy(void const * const /*p*/) const {
+        assert(false); // must be implemented if used
+    }
+};
+
+} // namespace serialization 
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP
+
diff --git a/ext/boost/serialization/extended_type_info_no_rtti.hpp b/ext/boost/serialization/extended_type_info_no_rtti.hpp
new file mode 100644
index 0000000000..549919852d
--- /dev/null
+++ b/ext/boost/serialization/extended_type_info_no_rtti.hpp
@@ -0,0 +1,132 @@
+#ifndef BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP
+#define BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// extended_type_info_no_rtti.hpp: implementation for version that depends
+// on runtime typing (rtti - typeid) but uses a user specified string
+// as the portable class identifier.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+#include <cassert>
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+
+#include <boost/serialization/singleton.hpp>
+#include <boost/serialization/extended_type_info.hpp>
+#include <boost/serialization/factory.hpp>
+
+#include <boost/config/abi_prefix.hpp> // must be the last header
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4251 4231 4660 4275)
+#endif
+
+namespace boost {
+namespace serialization {
+///////////////////////////////////////////////////////////////////////
+// define a special type_info that doesn't depend on rtti which is not
+// available in all situations.
+
+namespace detail {
+
+// common base class to share type_info_key.  This is used to 
+// identify the method used to keep track of the extended type
+class BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY()) extended_type_info_no_rtti_0 : 
+    public extended_type_info
+{
+protected:
+    extended_type_info_no_rtti_0();
+    ~extended_type_info_no_rtti_0();
+public:
+    virtual bool
+    is_less_than(const boost::serialization::extended_type_info &rhs) const ;
+    virtual bool
+    is_equal(const boost::serialization::extended_type_info &rhs) const ;
+};
+
+} // detail
+
+template<class T>
+class extended_type_info_no_rtti : 
+    public detail::extended_type_info_no_rtti_0,
+    public singleton<extended_type_info_no_rtti<T> >
+{
+public:
+    extended_type_info_no_rtti() :
+        detail::extended_type_info_no_rtti_0()
+    {}
+    const extended_type_info *
+    get_derived_extended_type_info(const T & t) const {
+        // find the type that corresponds to the most derived type.
+        // this implementation doesn't depend on typeid() but assumes
+        // that the specified type has a function of the following signature.
+        // A common implemention of such a function is to define as a virtual
+        // function. 
+        const char * derived_key = t.get_key();
+        assert(NULL != derived_key);
+        return boost::serialization::extended_type_info::find(derived_key);
+    }
+    void * construct(unsigned int count, ...) const{
+        // count up the arguments
+        std::va_list ap;
+        va_start(ap, count);
+        switch(count){
+        case 0:
+            return factory<T, 0>(ap);
+        case 1:
+            return factory<T, 1>(ap);
+        case 2:
+            return factory<T, 2>(ap);
+        case 3:
+            return factory<T, 3>(ap);
+        case 4:
+            return factory<T, 4>(ap);
+        default:
+            assert(false); // too many arguments
+            // throw exception here?
+            return NULL;
+        }
+    }
+    void destroy(void const * const p) const{
+        delete static_cast<T const *>(p) ;
+    }
+};
+
+} // namespace serialization
+} // namespace boost
+
+///////////////////////////////////////////////////////////////////////////////
+// If no other implementation has been designated as default, 
+// use this one.  To use this implementation as the default, specify it
+// before any of the other headers.
+
+#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
+    #define BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
+    namespace boost {
+    namespace serialization {
+    template<class T>
+    struct extended_type_info_impl {
+        typedef BOOST_DEDUCED_TYPENAME 
+            boost::serialization::extended_type_info_no_rtti<T> type;
+    };
+    } // namespace serialization
+    } // namespace boost
+#endif
+
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP
diff --git a/ext/boost/serialization/extended_type_info_typeid.hpp b/ext/boost/serialization/extended_type_info_typeid.hpp
new file mode 100644
index 0000000000..3930cb9ca2
--- /dev/null
+++ b/ext/boost/serialization/extended_type_info_typeid.hpp
@@ -0,0 +1,152 @@
+#ifndef BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP
+#define BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// extended_type_info_typeid.hpp: implementation for version that depends
+// on runtime typing (rtti - typeid) but uses a user specified string
+// as the portable class identifier.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <typeinfo>
+#include <cstdarg>
+#include <cassert>
+#include <boost/config.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/serialization/static_warning.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+#include <boost/serialization/singleton.hpp>
+#include <boost/serialization/extended_type_info.hpp>
+#include <boost/serialization/factory.hpp>
+
+#include <boost/config/abi_prefix.hpp> // must be the last header
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4251 4231 4660 4275)
+#endif
+
+namespace boost {
+namespace serialization {
+namespace detail {
+
+class BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY()) extended_type_info_typeid_0 : 
+    public extended_type_info
+{
+protected:
+    const std::type_info * m_ti;
+    extended_type_info_typeid_0();
+    ~extended_type_info_typeid_0();
+    void type_register(const std::type_info & ti);
+    void type_unregister();
+    const extended_type_info *
+    get_extended_type_info(const std::type_info & ti) const;
+public:
+    virtual bool
+    is_less_than(const extended_type_info &rhs) const;
+    virtual bool
+    is_equal(const extended_type_info &rhs) const;
+    const std::type_info & get_typeid() const {
+        return *m_ti;
+    }
+};
+
+} // namespace detail
+
+template<class T>
+class extended_type_info_typeid : 
+    public detail::extended_type_info_typeid_0,
+    public singleton<extended_type_info_typeid<T> >
+{
+public:
+    extended_type_info_typeid() :
+        detail::extended_type_info_typeid_0()
+    {
+        type_register(typeid(T));
+    }
+    ~extended_type_info_typeid(){
+        type_unregister();
+    }
+    // get the eti record for the true type of this record
+    // relying upon standard type info implemenation (rtti)
+    const extended_type_info *
+    get_derived_extended_type_info(const T & t) const {
+        // note: this implementation - based on usage of typeid (rtti)
+        // only does something if the class has at least one virtual function.
+        BOOST_STATIC_WARNING(boost::is_polymorphic<T>::value);
+        return 
+            detail::extended_type_info_typeid_0::get_extended_type_info(
+                typeid(t)
+            );
+    }
+    void * construct(unsigned int count, ...) const{
+        // count up the arguments
+        std::va_list ap;
+        va_start(ap, count);
+        switch(count){
+        case 0:
+            return factory<boost::remove_const<T>, 0>(ap);
+        case 1:
+            return factory<boost::remove_const<T>, 1>(ap);
+        case 2:
+            return factory<boost::remove_const<T>, 2>(ap);
+        case 3:
+            return factory<boost::remove_const<T>, 3>(ap);
+        case 4:
+            return factory<boost::remove_const<T>, 4>(ap);
+        default:
+            assert(false); // too many arguments
+            // throw exception here?
+            return NULL;
+        }
+    }
+    void destroy(void const * const /* p */) const {
+        // the only current usage of extended type info is in the
+        // serialization library.  The statement below requires
+        // that destructor of type T be public and this creates
+        // a problem for some users.  So, for now, comment this
+        // out 
+        //delete static_cast<T const *>(p);
+        // and trap any attempt to invoke this function
+        assert(false);
+    }
+};
+
+} // namespace serialization
+} // namespace boost
+
+///////////////////////////////////////////////////////////////////////////////
+// If no other implementation has been designated as default, 
+// use this one.  To use this implementation as the default, specify it
+// before any of the other headers.
+#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
+    #define BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
+    namespace boost {
+    namespace serialization {
+    template<class T>
+    struct extended_type_info_impl {
+        typedef BOOST_DEDUCED_TYPENAME 
+            boost::serialization::extended_type_info_typeid<T> type;
+    };
+    } // namespace serialization
+    } // namespace boost
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP
diff --git a/ext/boost/serialization/factory.hpp b/ext/boost/serialization/factory.hpp
new file mode 100644
index 0000000000..c7730cb8c4
--- /dev/null
+++ b/ext/boost/serialization/factory.hpp
@@ -0,0 +1,93 @@
+#ifndef BOOST_SERIALIZATION_FACTORY_HPP
+#define BOOST_SERIALIZATION_FACTORY_HPP
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// factory.hpp: create an instance from an extended_type_info instance.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <cstdarg> // valist
+#include <cstddef> // NULL
+
+#include <boost/preprocessor/control/if.hpp> 
+#include <boost/preprocessor/comparison/greater.hpp>
+#include <boost/preprocessor/facilities/empty.hpp>
+
+namespace std{
+    #if defined(__LIBCOMO__)
+        using ::va_list;
+    #endif
+} // namespace std
+
+namespace boost {
+namespace serialization {
+
+// default implementation does nothing.
+template<class T, int N>
+T * factory(std::va_list){
+    assert(false);
+    // throw exception here?
+    return NULL;
+}
+
+} // namespace serialization
+} // namespace boost
+
+#define BOOST_SERIALIZATION_FACTORY(N, T, A0, A1, A2, A3) \
+namespace boost {                                         \
+namespace serialization {                                 \
+    template<>                                            \
+    T * factory<T, N>(std::va_list ap){                   \
+        BOOST_PP_IF(BOOST_PP_GREATER(N,0)                 \
+            ,A0 a0 = va_arg(ap, A0);                      \
+        ,BOOST_PP_IF(BOOST_PP_GREATER(N,1)                \
+            ,A1 a1 = va_arg(ap, A1);                      \
+        ,BOOST_PP_IF(BOOST_PP_GREATER(N,2)                \
+            ,A2 a2 = va_arg(ap, A2);                      \
+        ,BOOST_PP_IF(BOOST_PP_GREATER(N,3)                \
+            ,A3 a3 = va_arg(ap, A3);                      \
+            ,BOOST_PP_EMPTY()                             \
+        ))))                                              \
+        return new T(                                     \
+            BOOST_PP_IF(BOOST_PP_GREATER(N,0)             \
+                ,a0                                       \
+            ,BOOST_PP_IF(BOOST_PP_GREATER(N,1)            \
+                ,a1                                       \
+            ,BOOST_PP_IF(BOOST_PP_GREATER(N,2)            \
+                ,a2                                       \
+            ,BOOST_PP_IF(BOOST_PP_GREATER(N,3)            \
+                ,a3                                       \
+                ,BOOST_PP_EMPTY()                         \
+            ))))                                          \
+        );                                                \
+    }                                                     \
+}                                                         \
+}                                                         \
+/**/
+
+#define BOOST_SERIALIZATION_FACTORY_4(T, A0, A1, A2, A3) \
+    BOOST_SERIALIZATION_FACTORY(4, T, A0, A1, A2, A3)
+
+#define BOOST_SERIALIZATION_FACTORY_3(T, A0, A1, A2)     \
+    BOOST_SERIALIZATION_FACTORY(3, T, A0, A1, A2, 0)
+
+#define BOOST_SERIALIZATION_FACTORY_2(T, A0, A1)         \
+    BOOST_SERIALIZATION_FACTORY(2, T, A0, A1, 0, 0)
+
+#define BOOST_SERIALIZATION_FACTORY_1(T, A0)             \
+    BOOST_SERIALIZATION_FACTORY(1, T, A0, 0, 0, 0)
+
+#define BOOST_SERIALIZATION_FACTORY_0(T)                 \
+    BOOST_SERIALIZATION_FACTORY(0, T, 0, 0, 0, 0)
+
+#endif // BOOST_SERIALIZATION_FACTORY_HPP
diff --git a/ext/boost/serialization/force_include.hpp b/ext/boost/serialization/force_include.hpp
new file mode 100644
index 0000000000..6801eef1fc
--- /dev/null
+++ b/ext/boost/serialization/force_include.hpp
@@ -0,0 +1,57 @@
+#ifndef BOOST_SERIALIZATION_FORCE_INCLUDE_HPP
+#define BOOST_SERIALIZATION_FORCE_INCLUDE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// force_include.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+
+// the following help macro is to guarentee that certain coded
+// is not removed by over-eager linker optimiser.  In certain cases
+// we create static objects must be created but are actually never
+// referenced - creation has a side-effect such as global registration
+// which is important to us. We make an effort to refer these objects
+// so that a smart linker won't remove them as being unreferenced.
+// In microsoft compilers, inlining the code that does the referring
+// means the code gets lost and the static object is not included
+// in the library and hence never registered.  This manifests itself
+// in an ungraceful crash at runtime when (and only when) built in
+// release mode.
+
+#if defined(BOOST_HAS_DECLSPEC) && !defined(__COMO__)
+#   if defined(__BORLANDC__)
+#       define BOOST_DLLEXPORT __export
+#   else
+#       define BOOST_DLLEXPORT __declspec(dllexport)
+#   endif
+#elif ! defined(_WIN32) && ! defined(_WIN64)
+#   if defined(__MWERKS__)
+#       define BOOST_DLLEXPORT __declspec(dllexport)
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)
+#       define BOOST_USED __attribute__ ((used))
+#   elif defined(__INTEL_COMPILER) && (BOOST_INTEL_CXX_VERSION >= 800)
+#       define BOOST_USED __attribute__ ((used))
+#   endif
+#endif
+
+#ifndef BOOST_USED
+#    define BOOST_USED
+#endif
+
+#ifndef BOOST_DLLEXPORT
+#    define BOOST_DLLEXPORT
+#endif
+
+#endif // BOOST_SERIALIZATION_FORCE_INCLUDE_HPP
diff --git a/ext/boost/serialization/hash_collections_load_imp.hpp b/ext/boost/serialization/hash_collections_load_imp.hpp
new file mode 100644
index 0000000000..cd5bea8d18
--- /dev/null
+++ b/ext/boost/serialization/hash_collections_load_imp.hpp
@@ -0,0 +1,58 @@
+#ifndef BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP
+#define BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// hash_collections_load_imp.hpp: serialization for loading stl collections
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+// helper function templates for serialization of hashed collections
+#include <boost/config.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+
+namespace boost{
+namespace serialization {
+namespace stl {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of serialization for STL containers
+//
+template<class Archive, class Container, class InputFunction>
+inline void load_hash_collection(Archive & ar, Container &s)
+{
+    s.clear();
+    // retrieve number of elements
+    unsigned int count;
+    unsigned int item_version(0);
+    unsigned int bucket_count;;
+    ar >> BOOST_SERIALIZATION_NVP(count);
+    if(3 < ar.get_library_version()){
+       ar >> BOOST_SERIALIZATION_NVP(bucket_count);
+       ar >> BOOST_SERIALIZATION_NVP(item_version);
+    }
+    #if ! defined(__MWERKS__)
+    s.resize(bucket_count);
+    #endif
+    InputFunction ifunc;
+    while(count-- > 0){
+        ifunc(ar, s, item_version);
+    }
+}
+
+} // namespace stl 
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP
diff --git a/ext/boost/serialization/hash_collections_save_imp.hpp b/ext/boost/serialization/hash_collections_save_imp.hpp
new file mode 100644
index 0000000000..e0dc0a24df
--- /dev/null
+++ b/ext/boost/serialization/hash_collections_save_imp.hpp
@@ -0,0 +1,66 @@
+#ifndef BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_HPP
+#define BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// hash_collections_save_imp.hpp: serialization for stl collections
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+// helper function templates for serialization of collections
+
+#include <boost/config.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/version.hpp>
+
+namespace boost{
+namespace serialization {
+namespace stl {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of serialization for STL containers
+//
+
+template<class Archive, class Container>
+inline void save_hash_collection(Archive & ar, const Container &s)
+{
+    // record number of elements
+    unsigned int count = s.size();
+    ar <<  BOOST_SERIALIZATION_NVP(count);
+    // make sure the target type is registered so we can retrieve
+    // the version when we load
+    if(3 < ar.get_library_version()){
+        const unsigned int bucket_count = s.bucket_count();
+        ar << BOOST_SERIALIZATION_NVP(bucket_count);
+        const unsigned int item_version = version<BOOST_DEDUCED_TYPENAME Container::value_type>::value;
+        ar << BOOST_SERIALIZATION_NVP(item_version);
+    }
+    BOOST_DEDUCED_TYPENAME Container::const_iterator it = s.begin();
+    while(count-- > 0){
+        // note borland emits a no-op without the explicit namespace
+        boost::serialization::save_construct_data_adl(
+            ar, 
+            &(*it), 
+            boost::serialization::version<
+                BOOST_DEDUCED_TYPENAME Container::value_type
+            >::value
+        );
+        ar << boost::serialization::make_nvp("item", *it++);
+    }
+}
+
+} // namespace stl 
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_HPP
diff --git a/ext/boost/serialization/hash_map.hpp b/ext/boost/serialization/hash_map.hpp
new file mode 100644
index 0000000000..06d4c306dc
--- /dev/null
+++ b/ext/boost/serialization/hash_map.hpp
@@ -0,0 +1,175 @@
+#ifndef  BOOST_SERIALIZATION_HASH_MAP_HPP
+#define BOOST_SERIALIZATION_HASH_MAP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization/hash_map.hpp:
+// serialization for stl hash_map templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_HASH
+#include BOOST_HASH_MAP_HEADER
+
+#include <boost/serialization/utility.hpp>
+#include <boost/serialization/hash_collections_save_imp.hpp>
+#include <boost/serialization/hash_collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void save(
+    Archive & ar,
+    const BOOST_STD_EXTENSION_NAMESPACE::hash_map<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::save_hash_collection<
+        Archive, 
+        BOOST_STD_EXTENSION_NAMESPACE::hash_map<
+            Key, HashFcn, EqualKey, Allocator
+        >
+    >(ar, t);
+}
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void load(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::hash_map<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::load_hash_collection<
+        Archive,
+        BOOST_STD_EXTENSION_NAMESPACE::hash_map<
+            Key, HashFcn, EqualKey, Allocator
+        >,
+        boost::serialization::stl::archive_input_map<
+            Archive, 
+            BOOST_STD_EXTENSION_NAMESPACE::hash_map<
+                Key, HashFcn, EqualKey, Allocator
+            >
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void serialize(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::hash_map<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+// hash_multimap
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void save(
+    Archive & ar,
+    const BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::save_hash_collection<
+        Archive, 
+        BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
+            Key, HashFcn, EqualKey, Allocator
+        >
+    >(ar, t);
+}
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void load(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::load_hash_collection<
+        Archive,
+        BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
+            Key, HashFcn, EqualKey, Allocator
+        >,
+        boost::serialization::stl::archive_input_multimap<
+            Archive, 
+            BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
+                Key, HashFcn, EqualKey, Allocator
+            >
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void serialize(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_HAS_HASH
+#endif // BOOST_SERIALIZATION_HASH_MAP_HPP
diff --git a/ext/boost/serialization/hash_set.hpp b/ext/boost/serialization/hash_set.hpp
new file mode 100644
index 0000000000..62aeea4601
--- /dev/null
+++ b/ext/boost/serialization/hash_set.hpp
@@ -0,0 +1,178 @@
+#ifndef  BOOST_SERIALIZATION_HASH_SET_HPP
+#define BOOST_SERIALIZATION_HASH_SET_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// hash_set.hpp: serialization for stl hash_set templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_HASH
+#include BOOST_HASH_SET_HEADER
+
+#include <boost/serialization/hash_collections_save_imp.hpp>
+#include <boost/serialization/hash_collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void save(
+    Archive & ar,
+    const BOOST_STD_EXTENSION_NAMESPACE::hash_set<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::save_hash_collection<
+        Archive, 
+        BOOST_STD_EXTENSION_NAMESPACE::hash_set<
+            Key, HashFcn, EqualKey, Allocator
+        > 
+    >(ar, t);
+}
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void load(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::hash_set<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::load_hash_collection<
+        Archive,
+        BOOST_STD_EXTENSION_NAMESPACE::hash_set<
+            Key, HashFcn, EqualKey, Allocator
+        >,
+        boost::serialization::stl::archive_input_set<
+            Archive, 
+            BOOST_STD_EXTENSION_NAMESPACE::hash_set<
+                Key, HashFcn, EqualKey, Allocator
+            >
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void serialize(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::hash_set<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+// hash_multiset
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void save(
+    Archive & ar,
+    const BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::save_hash_collection<
+        Archive, 
+        BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
+            Key, HashFcn, EqualKey, Allocator
+        > 
+    >(ar, t);
+}
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void load(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::load_hash_collection<
+        Archive,
+        BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
+            Key, HashFcn, EqualKey, Allocator
+        >,
+        boost::serialization::stl::archive_input_multiset<
+            Archive,
+            BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
+                Key, HashFcn, EqualKey, Allocator
+            > 
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void serialize(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
+        Key, HashFcn, EqualKey, Allocator
+    > & t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(BOOST_STD_EXTENSION_NAMESPACE::hash_set)
+BOOST_SERIALIZATION_COLLECTION_TRAITS(BOOST_STD_EXTENSION_NAMESPACE::hash_multiset)
+
+#endif // BOOST_HAS_HASH
+#endif // BOOST_SERIALIZATION_HASH_SET_HPP
diff --git a/ext/boost/serialization/is_bitwise_serializable.hpp b/ext/boost/serialization/is_bitwise_serializable.hpp
new file mode 100644
index 0000000000..97d80b9a5b
--- /dev/null
+++ b/ext/boost/serialization/is_bitwise_serializable.hpp
@@ -0,0 +1,46 @@
+// (C) Copyright 2007 Matthias Troyer
+
+// Use, modification and distribution is subject to 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)
+
+//  Authors: Matthias Troyer
+
+/** @file is_bitwise_serializable.hpp
+ *
+ *  This header provides a traits class for determining whether a class
+ * can be serialized (in a non-portable way) just by copying the bits.
+ */
+
+
+#ifndef BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP
+#define BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/mpl/bool.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
+
+namespace boost {
+namespace serialization {
+    template<class T>
+    struct is_bitwise_serializable
+     : public is_arithmetic<T>
+    {};
+} // namespace serialization
+} // namespace boost
+
+
+// define a macro to make explicit designation of this more transparent
+#define BOOST_IS_BITWISE_SERIALIZABLE(T)              \
+namespace boost {                                     \
+namespace serialization {                             \
+template<>                                            \
+struct is_bitwise_serializable< T > : mpl::true_ {};  \
+}}                                                    \
+/**/
+
+#endif //BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP
diff --git a/ext/boost/serialization/level.hpp b/ext/boost/serialization/level.hpp
new file mode 100644
index 0000000000..a851c7f30a
--- /dev/null
+++ b/ext/boost/serialization/level.hpp
@@ -0,0 +1,120 @@
+#ifndef BOOST_SERIALIZATION_LEVEL_HPP
+#define BOOST_SERIALIZATION_LEVEL_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// level.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/type_traits/is_fundamental.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_array.hpp>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+#include <boost/mpl/aux_/nttp_decl.hpp>
+
+#include <boost/serialization/level_enum.hpp>
+
+namespace boost {
+namespace serialization {
+
+struct basic_traits;
+
+// default serialization implementation level
+template<class T>
+struct implementation_level {
+    template<class U>
+    struct traits_class_level {
+        typedef  BOOST_DEDUCED_TYPENAME U::level type;
+    };
+
+    typedef mpl::integral_c_tag tag;
+    // note: at least one compiler complained w/o the full qualification
+    // on basic traits below
+    typedef
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<
+            is_base_and_derived<boost::serialization::basic_traits, T>,
+            traits_class_level<T>,
+        //else
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<
+            is_fundamental<T>,
+            mpl::int_<primitive_type>,
+        //else
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<
+            is_class<T>,
+            mpl::int_<object_class_info>,
+        //else
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<
+            is_array<T>,
+            #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
+                mpl::int_<not_serializable>,
+            #else
+                mpl::int_<object_serializable>,
+            #endif
+        //else
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<
+            is_enum<T>,
+            //#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
+            //    mpl::int_<not_serializable>,
+            //#else
+                mpl::int_<primitive_type>,
+            //#endif
+        //else
+            mpl::int_<not_serializable>
+        >
+        >
+        >
+        >
+        >::type type;
+        // vc 7.1 doesn't like enums here
+    BOOST_STATIC_CONSTANT(int, value = implementation_level::type::value);
+};
+
+
+template<class T, BOOST_MPL_AUX_NTTP_DECL(int, L) >
+inline bool operator>=(implementation_level<T> t, enum level_type l)
+{
+    return t.value >= (int)l;
+}
+
+} // namespace serialization
+} // namespace boost
+
+// specify the level of serialization implementation for the class
+// require that class info saved when versioning is used
+#define BOOST_CLASS_IMPLEMENTATION(T, E)                 \
+    namespace boost {                                    \
+    namespace serialization {                            \
+    template <>                                          \
+    struct implementation_level< T >                     \
+    {                                                    \
+        typedef mpl::integral_c_tag tag;                 \
+        typedef mpl::int_< E > type;                     \
+        BOOST_STATIC_CONSTANT(                           \
+            int,                                         \
+            value = implementation_level::type::value    \
+        );                                               \
+    };                                                   \
+    }                                                    \
+    }
+    /**/
+
+#endif // BOOST_SERIALIZATION_LEVEL_HPP
diff --git a/ext/boost/serialization/level_enum.hpp b/ext/boost/serialization/level_enum.hpp
new file mode 100644
index 0000000000..11bd17f67d
--- /dev/null
+++ b/ext/boost/serialization/level_enum.hpp
@@ -0,0 +1,55 @@
+#ifndef BOOST_SERIALIZATION_LEVEL_ENUM_HPP
+#define BOOST_SERIALIZATION_LEVEL_ENUM_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// level_enum.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+namespace boost {
+namespace serialization {
+
+// for each class used in the program, specify which level
+// of serialization should be implemented
+
+// names for each level
+enum level_type
+{
+    // Don't serialize this type. An attempt to do so should
+    // invoke a compile time assertion.
+    not_serializable = 0,
+    // write/read this type directly to the archive. In this case
+    // serialization code won't be called.  This is the default
+    // case for fundamental types.  It presumes a member function or
+    // template in the archive class that can handle this type.
+    // there is no runtime overhead associated reading/writing
+    // instances of this level
+    primitive_type = 1,
+    // Serialize the objects of this type using the objects "serialize"
+    // function or template. This permits values to be written/read
+    // to/from archives but includes no class or version information. 
+    object_serializable = 2,
+    ///////////////////////////////////////////////////////////////////
+    // once an object is serialized at one of the above levels, the
+    // corresponding archives cannot be read if the implementation level
+    // for the archive object is changed.  
+    ///////////////////////////////////////////////////////////////////
+    // Add class information to the archive.  Class information includes
+    // implementation level, class version and class name if available
+    object_class_info = 3
+};
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_LEVEL_ENUM_HPP
diff --git a/ext/boost/serialization/list.hpp b/ext/boost/serialization/list.hpp
new file mode 100644
index 0000000000..469bb230ec
--- /dev/null
+++ b/ext/boost/serialization/list.hpp
@@ -0,0 +1,77 @@
+#ifndef BOOST_SERIALIZATION_LIST_HPP
+#define BOOST_SERIALIZATION_LIST_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// list.hpp: serialization for stl list templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <list>
+
+#include <boost/config.hpp>
+
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class U, class Allocator>
+inline void save(
+    Archive & ar,
+    const std::list<U, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    boost::serialization::stl::save_collection<
+        Archive, 
+        std::list<U, Allocator> 
+    >(ar, t);
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+    Archive & ar,
+    std::list<U, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    boost::serialization::stl::load_collection<
+        Archive,
+        std::list<U, Allocator>,
+        boost::serialization::stl::archive_input_seq<
+            Archive, 
+            std::list<U, Allocator> 
+        >,
+        boost::serialization::stl::no_reserve_imp<std::list<U, Allocator> >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U, class Allocator>
+inline void serialize(
+    Archive & ar,
+    std::list<U, Allocator> & t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(std::list)
+
+#endif // BOOST_SERIALIZATION_LIST_HPP
diff --git a/ext/boost/serialization/map.hpp b/ext/boost/serialization/map.hpp
new file mode 100644
index 0000000000..6cf965ff8b
--- /dev/null
+++ b/ext/boost/serialization/map.hpp
@@ -0,0 +1,118 @@
+#ifndef  BOOST_SERIALIZATION_MAP_HPP
+#define BOOST_SERIALIZATION_MAP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization/map.hpp:
+// serialization for stl map templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <map>
+
+#include <boost/config.hpp>
+
+#include <boost/serialization/utility.hpp>
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class Type, class Key, class Compare, class Allocator >
+inline void save(
+    Archive & ar,
+    const std::map<Key, Type, Compare, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    boost::serialization::stl::save_collection<
+        Archive, 
+        std::map<Key, Type, Compare, Allocator> 
+    >(ar, t);
+}
+
+template<class Archive, class Type, class Key, class Compare, class Allocator >
+inline void load(
+    Archive & ar,
+    std::map<Key, Type, Compare, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    boost::serialization::stl::load_collection<
+        Archive,
+        std::map<Key, Type, Compare, Allocator>,
+        boost::serialization::stl::archive_input_map<
+            Archive, std::map<Key, Type, Compare, Allocator> >,
+            boost::serialization::stl::no_reserve_imp<std::map<
+                Key, Type, Compare, Allocator
+            >
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class Type, class Key, class Compare, class Allocator >
+inline void serialize(
+    Archive & ar,
+    std::map<Key, Type, Compare, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+// multimap
+template<class Archive, class Type, class Key, class Compare, class Allocator >
+inline void save(
+    Archive & ar,
+    const std::multimap<Key, Type, Compare, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    boost::serialization::stl::save_collection<
+        Archive, 
+        std::multimap<Key, Type, Compare, Allocator> 
+    >(ar, t);
+}
+
+template<class Archive, class Type, class Key, class Compare, class Allocator >
+inline void load(
+    Archive & ar,
+    std::multimap<Key, Type, Compare, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    boost::serialization::stl::load_collection<
+        Archive,
+        std::multimap<Key, Type, Compare, Allocator>,
+        boost::serialization::stl::archive_input_multimap<
+            Archive, std::multimap<Key, Type, Compare, Allocator> 
+        >,
+        boost::serialization::stl::no_reserve_imp<
+            std::multimap<Key, Type, Compare, Allocator> 
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class Type, class Key, class Compare, class Allocator >
+inline void serialize(
+    Archive & ar,
+    std::multimap<Key, Type, Compare, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_MAP_HPP
diff --git a/ext/boost/serialization/nvp.hpp b/ext/boost/serialization/nvp.hpp
new file mode 100644
index 0000000000..ade67b425b
--- /dev/null
+++ b/ext/boost/serialization/nvp.hpp
@@ -0,0 +1,143 @@
+#ifndef BOOST_SERIALIZATION_NVP_HPP
+#define BOOST_SERIALIZATION_NVP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// nvp.hpp: interface for serialization system.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <utility>
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+// supress noise
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/base_object.hpp>
+#include <boost/serialization/traits.hpp>
+#include <boost/serialization/wrapper.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<class T>
+struct nvp : 
+    public std::pair<const char *, T *>,
+    public wrapper_traits<nvp<T> >
+{
+    explicit nvp(const char * name, T & t) :
+        // note: redundant cast works around borland issue
+        std::pair<const char *, T *>(name, (T*)(& t))
+    {}
+    nvp(const nvp & rhs) : 
+        // note: redundant cast works around borland issue
+        std::pair<const char *, T *>(rhs.first, (T*)rhs.second)
+    {}
+
+    const char * name() const {
+        return this->first;
+    }
+    T & value() const {
+        return *(this->second);
+    }
+
+    const T & const_value() const {
+        return *(this->second);
+    }
+
+    // True64 compiler complains with a warning about the use of
+    // the name "Archive" hiding some higher level usage.  I'm sure this
+    // is an error but I want to accomodated as it generates a long warning
+    // listing and might be related to a lot of test failures.
+    // default treatment for name-value pairs. The name is
+    // just discarded and only the value is serialized. 
+    template<class Archivex>
+    void save(
+        Archivex & ar, 
+        const unsigned int /* file_version */
+    ) const {
+        // CodeWarrior 8.x can't seem to resolve the << op for a rhs of "const T *"
+        ar.operator<<(const_value());
+    }
+    template<class Archivex>
+    void load(
+        Archivex & ar, 
+        const unsigned int /* file_version */
+    ){
+        // CodeWarrior 8.x can't seem to resolve the >> op for a rhs of "const T *"
+        ar.operator>>(value());
+    }
+    BOOST_SERIALIZATION_SPLIT_MEMBER()
+};
+
+template<class T>
+inline
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+const
+#endif
+nvp<T> make_nvp(const char * name, T & t){
+    return nvp<T>(name, t);
+}
+
+// to maintain efficiency and portability, we want to assign
+// specific serialization traits to all instances of this wrappers.
+// we can't strait forward method below as it depends upon
+// Partial Template Specialization and doing so would mean that wrappers
+// wouldn't be treated the same on different platforms.  This would
+// break archive portability. Leave this here as reminder not to use it !!!
+#if 0 // #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+template <class T>
+struct implementation_level<nvp<T> >
+{
+    typedef mpl::integral_c_tag tag;
+    typedef mpl::int_<object_serializable> type;
+    BOOST_STATIC_CONSTANT(int, value = implementation_level::type::value);
+};
+
+// nvp objects are generally created on the stack and are never tracked
+template<class T>
+struct tracking_level<nvp<T> >
+{
+    typedef mpl::integral_c_tag tag;
+    typedef mpl::int_<track_never> type;
+    BOOST_STATIC_CONSTANT(int, value = tracking_level::type::value);
+};
+
+#endif
+
+} // seralization
+} // boost
+
+#include <boost/preprocessor/stringize.hpp>
+
+#define BOOST_SERIALIZATION_NVP(name)                              \
+    boost::serialization::make_nvp(BOOST_PP_STRINGIZE(name), name)
+/**/
+
+#define BOOST_SERIALIZATION_BASE_OBJECT_NVP(name)                  \
+    boost::serialization::make_nvp(                                \
+        BOOST_PP_STRINGIZE(name),                                  \
+        boost::serialization::base_object<name >(*this)            \
+    )
+/**/
+
+#endif // BOOST_SERIALIZATION_NVP_HPP
diff --git a/ext/boost/serialization/optional.hpp b/ext/boost/serialization/optional.hpp
new file mode 100644
index 0000000000..68d236b71d
--- /dev/null
+++ b/ext/boost/serialization/optional.hpp
@@ -0,0 +1,113 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+
+// (C) Copyright 2002-4 Pavel Vozenilek . 
+// Use, modification and distribution is subject to 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)
+
+// Provides non-intrusive serialization for boost::optional.
+
+#ifndef BOOST_SERIALIZATION_OPTIONAL_HPP_
+#define BOOST_SERIALIZATION_OPTIONAL_HPP_
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/optional.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/detail/stack_constructor.hpp>
+
+// function specializations must be defined in the appropriate
+// namespace - boost::serialization
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class T>
+void save(
+    Archive & ar, 
+    const boost::optional<T> & t, 
+    const unsigned int /*version*/
+){
+    const bool tflag = t.is_initialized();
+    ar << boost::serialization::make_nvp("initialized", tflag);
+    if (tflag){
+        if(3 < ar.get_library_version()){
+            const int v = version<T>::value;
+            ar << boost::serialization::make_nvp("item_version", v);
+        }
+        ar << boost::serialization::make_nvp("value", *t);
+    }
+}
+
+template<class Archive, class T>
+void load(
+    Archive & ar, 
+    boost::optional<T> & t, 
+    const unsigned int /*version*/
+){
+    bool tflag;
+    ar >> boost::serialization::make_nvp("initialized", tflag);
+    if (tflag){
+        unsigned int v = 0;
+        if(3 < ar.get_library_version()){
+            ar >> boost::serialization::make_nvp("item_version", v);
+        }
+        detail::stack_construct<Archive, T> aux(ar, v);
+        ar >> boost::serialization::make_nvp("value", aux.reference());
+        t.reset(aux.reference());
+    }
+    else {
+        t.reset();
+    }
+}
+
+template<class Archive, class T>
+void serialize(
+    Archive & ar, 
+    boost::optional<T> & t, 
+    const unsigned int version
+){
+    boost::serialization::split_free(ar, t, version);
+}
+
+// the following would be slightly more efficient.  But it
+// would mean that archives created with programs that support
+// TPS wouldn't be readable by programs that don't support TPS.
+// Hence we decline to support this otherwise convenient optimization.
+//#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#if 0
+
+template <class T>
+struct implementation_level<optional<T> >
+{
+    typedef mpl::integral_c_tag tag;
+    typedef mpl::int_<boost::serialization::object_serializable> type;
+    BOOST_STATIC_CONSTANT(
+        int , 
+        value = boost::serialization::implementation_level::type::value
+    );
+};
+
+template<class T>
+struct tracking_level<optional<T> >
+{
+    typedef mpl::integral_c_tag tag;
+    typedef mpl::int_<boost::serialization::track_never> type;
+    BOOST_STATIC_CONSTANT(
+        int , 
+        value = boost::serialization::tracking_level::type::value
+    );
+};
+
+#endif
+
+} // serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_OPTIONAL_HPP_
diff --git a/ext/boost/serialization/pfto.hpp b/ext/boost/serialization/pfto.hpp
new file mode 100644
index 0000000000..109f6d44e8
--- /dev/null
+++ b/ext/boost/serialization/pfto.hpp
@@ -0,0 +1,78 @@
+#ifndef BOOST_SERIALIZATION_PFTO_HPP
+#define BOOST_SERIALIZATION_PFTO_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// pfto.hpp: workarounds for compilers which have problems supporting
+// Partial Function Template Ordering (PFTO).
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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/serialization for updates, documentation, and revision history.
+// PFTO version is used to specify the last argument of certain functions
+// Function it is used to support  compilers that fail to support correct Partial 
+// Template Ordering
+#include <boost/config.hpp>
+
+// some compilers can use an exta argument and use function overloading
+// to choose desired function.  This extra argument is long in the default
+// function implementation and int for the rest.  The function is called
+// with an int argument.  This first attempts to match functions with an
+// int argument before the default one (with a long argument).  This is
+// known to function with VC 6.0. On other compilers this fails (Borland)
+// or causes other problems (GCC).  note: this 
+
+#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+    #define BOOST_PFTO long
+#else
+    #define BOOST_PFTO
+#endif
+
+// here's another approach.  Rather than use a default function - make sure
+// there is no default at all by requiring that all function invocations
+// have a "wrapped" argument type.  This solves a problem with VC 6.0
+// (and perhaps others) while implementing templated constructors.
+
+namespace boost {
+namespace serialization {
+
+template<class T>
+struct pfto_wrapper {
+    const T & t;
+    operator const T & (){
+        return t;
+    }
+    pfto_wrapper (const T & rhs) : t(rhs) {}
+};
+
+template<class T>
+pfto_wrapper<T> make_pfto_wrapper(const T & t, BOOST_PFTO int){
+    return pfto_wrapper<T>(t);
+}
+
+template<class T>
+pfto_wrapper<T> make_pfto_wrapper(const pfto_wrapper<T> & t, int){
+    return t;
+}
+
+} // namespace serialization
+} // namespace boost
+
+#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+    #define BOOST_PFTO_WRAPPER(T) \
+        boost::serialization::pfto_wrapper<T>
+    #define BOOST_MAKE_PFTO_WRAPPER(t) \
+        boost::serialization::make_pfto_wrapper(t, 0)
+#else
+    #define BOOST_PFTO_WRAPPER(T) T
+    #define BOOST_MAKE_PFTO_WRAPPER(t) t
+#endif
+
+#endif // BOOST_SERIALIZATION_PFTO_HPP
diff --git a/ext/boost/serialization/scoped_ptr.hpp b/ext/boost/serialization/scoped_ptr.hpp
new file mode 100644
index 0000000000..52642c7dc6
--- /dev/null
+++ b/ext/boost/serialization/scoped_ptr.hpp
@@ -0,0 +1,58 @@
+#ifndef BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30
+#define BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  Copyright (c) 2003 Vladimir Prus.
+// Use, modification and distribution is subject to 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)
+
+// Provides non-intrusive serialization for boost::scoped_ptr
+// Does not allow to serialize scoped_ptr's to builtin types.
+
+#include <boost/config.hpp>
+
+#include <boost/scoped_ptr.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost { 
+namespace serialization {
+    
+    template<class Archive, class T>
+    void save(
+        Archive & ar, 
+        const boost::scoped_ptr<T> & t, 
+        const unsigned int /* version */
+    ){
+        T* r = t.get();
+        ar << boost::serialization::make_nvp("scoped_ptr", r);
+    }
+
+    template<class Archive, class T>
+    void load(
+        Archive & ar, 
+        boost::scoped_ptr<T> & t, 
+        const unsigned int /* version */
+    ){
+        T* r;
+        ar >> boost::serialization::make_nvp("scoped_ptr", r);
+        t.reset(r); 
+    }
+
+    template<class Archive, class T>
+    void serialize(
+        Archive& ar, 
+        boost::scoped_ptr<T>& t, 
+        const unsigned int version
+    ){
+        boost::serialization::split_free(ar, t, version);
+    }
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30
diff --git a/ext/boost/serialization/serialization.hpp b/ext/boost/serialization/serialization.hpp
new file mode 100644
index 0000000000..0e506db9a2
--- /dev/null
+++ b/ext/boost/serialization/serialization.hpp
@@ -0,0 +1,172 @@
+#ifndef BOOST_SERIALIZATION_SERIALIZATION_HPP
+#define BOOST_SERIALIZATION_SERIALIZATION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1310)
+#  pragma warning (disable : 4675) // suppress ADL warning
+#endif
+
+#include <boost/config.hpp>
+#include <boost/serialization/strong_typedef.hpp>
+#include <boost/serialization/pfto.hpp>
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/serialization/nvp.hpp>
+
+// incremented for each "release"
+#define BOOST_SERIALIZATION_LIBRARY_VERSION 19
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization.hpp: interface for serialization system.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+//////////////////////////////////////////////////////////////////////
+// public interface to serialization. 
+
+/////////////////////////////////////////////////////////////////////////////
+// layer 0 - intrusive verison
+// declared and implemented for each user defined class to be serialized
+//
+//  template<Archive>
+//  serialize(Archive &ar, const unsigned int file_version){
+//      ar & base_object<base>(*this) & member1 & member2 ... ;
+//  }
+
+/////////////////////////////////////////////////////////////////////////////
+// layer 1 - layer that routes member access through the access class.
+// this is what permits us to grant access to private class member functions
+// by specifying friend class boost::serialization::access
+
+#include <boost/serialization/access.hpp>
+
+/////////////////////////////////////////////////////////////////////////////
+// layer 2 - default implementation of non-intrusive serialization.
+//
+// note the usage of function overloading to compensate that C++ does not
+// currently support Partial Template Specialization for function templates 
+// We have declared the version number as "const unsigned long".  
+// Overriding templates for specific data types should declare the version
+// number as "const unsigned int". Template matching will first be applied
+// to functions with the same version types - that is the overloads.  
+// If there is no declared function prototype that matches, the second argument
+// will be converted to "const unsigned long" and a match will be made with 
+// one of the default template functions below.
+
+namespace boost {
+namespace serialization {
+
+BOOST_STRONG_TYPEDEF(unsigned int, version_type)
+
+// default implemenation - call the member function "serialize"
+template<class Archive, class T>
+inline void serialize(
+    Archive & ar, T & t, const BOOST_PFTO unsigned int file_version
+){
+    access::serialize(ar, t, static_cast<unsigned int>(file_version));
+}
+
+// save data required for construction
+template<class Archive, class T>
+inline void save_construct_data(
+    Archive & /*ar*/, 
+    const T * /*t*/, 
+    const BOOST_PFTO unsigned int /*file_version */
+){
+    // default is to save no data because default constructor
+    // requires no arguments.
+}
+
+// load data required for construction and invoke constructor in place
+template<class Archive, class T>
+inline void load_construct_data(
+    Archive & ar, 
+    T * t, 
+    const BOOST_PFTO unsigned int /*file_version*/
+){
+    // default just uses the default constructor.  going
+    // through access permits usage of otherwise private default
+    // constructor
+    access::construct(t);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// layer 3 - move call into serialization namespace so that ADL will function
+// in the manner we desire.
+//
+// on compilers which don't implement ADL. only the current namespace
+// i.e. boost::serialization will be searched.
+// 
+// on compilers which DO implement ADL
+// serialize overrides can be in any of the following
+// 
+// 1) same namepace as Archive
+// 2) same namespace as T
+// 3) boost::serialization
+//
+// Due to Martin Ecker
+
+template<class Archive, class T>
+inline void serialize_adl(
+    Archive & ar, 
+    T & t, 
+    const unsigned int file_version
+){
+    // note usage of function overloading to delay final resolution
+    // until the point of instantiation.  This works around the two-phase
+    // lookup "feature" which inhibits redefintion of a default function
+    // template implementation. Due to Robert Ramey
+    //
+    // Note that this trick generates problems for compiles which don't support
+    // PFTO, suppress it here.  As far as we know, there are no compilers
+    // which fail to support PFTO while supporting two-phase lookup.
+    #if ! defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+        const version_type v(file_version);
+        serialize(ar, t, v);
+    #else
+        serialize(ar, t, file_version);
+    #endif
+}
+
+template<class Archive, class T>
+inline void save_construct_data_adl(
+    Archive & ar, 
+    const T * t, 
+    const unsigned int file_version
+){
+    // see above
+    #if ! defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+        const version_type v(file_version);
+        save_construct_data(ar, t, v);
+    #else
+        save_construct_data(ar, t, file_version);
+    #endif
+}
+
+template<class Archive, class T>
+inline void load_construct_data_adl(
+    Archive & ar, 
+    T * t, 
+    const unsigned int file_version
+){
+    // see above comment
+    #if ! defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+        const version_type v(file_version);
+        load_construct_data(ar, t, v);
+    #else
+        load_construct_data(ar, t, file_version);
+    #endif
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_SERIALIZATION_HPP
diff --git a/ext/boost/serialization/set.hpp b/ext/boost/serialization/set.hpp
new file mode 100644
index 0000000000..c67c27ed4d
--- /dev/null
+++ b/ext/boost/serialization/set.hpp
@@ -0,0 +1,120 @@
+#ifndef  BOOST_SERIALIZATION_SET_HPP
+#define BOOST_SERIALIZATION_SET_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// set.hpp: serialization for stl set templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <set>
+
+#include <boost/config.hpp>
+
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class Key, class Compare, class Allocator >
+inline void save(
+    Archive & ar,
+    const std::set<Key, Compare, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    boost::serialization::stl::save_collection<
+        Archive, std::set<Key, Compare, Allocator> 
+    >(ar, t);
+}
+
+template<class Archive, class Key, class Compare, class Allocator >
+inline void load(
+    Archive & ar,
+    std::set<Key, Compare, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    boost::serialization::stl::load_collection<
+        Archive,
+        std::set<Key, Compare, Allocator>,
+        boost::serialization::stl::archive_input_set<
+            Archive, std::set<Key, Compare, Allocator> 
+        >,
+        boost::serialization::stl::no_reserve_imp<std::set<
+            Key, Compare, Allocator> 
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class Key, class Compare, class Allocator >
+inline void serialize(
+    Archive & ar,
+    std::set<Key, Compare, Allocator> & t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+// multiset
+template<class Archive, class Key, class Compare, class Allocator >
+inline void save(
+    Archive & ar,
+    const std::multiset<Key, Compare, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    boost::serialization::stl::save_collection<
+        Archive, 
+        std::multiset<Key, Compare, Allocator> 
+    >(ar, t);
+}
+
+template<class Archive, class Key, class Compare, class Allocator >
+inline void load(
+    Archive & ar,
+    std::multiset<Key, Compare, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    boost::serialization::stl::load_collection<
+        Archive,
+        std::multiset<Key, Compare, Allocator>,
+        boost::serialization::stl::archive_input_multiset<
+            Archive, std::multiset<Key, Compare, Allocator> 
+        >,
+        boost::serialization::stl::no_reserve_imp<
+            std::multiset<Key, Compare, Allocator> 
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class Key, class Compare, class Allocator >
+inline void serialize(
+    Archive & ar,
+    std::multiset<Key, Compare, Allocator> & t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(std::set)
+BOOST_SERIALIZATION_COLLECTION_TRAITS(std::multiset)
+
+#endif // BOOST_SERIALIZATION_SET_HPP
diff --git a/ext/boost/serialization/shared_ptr.hpp b/ext/boost/serialization/shared_ptr.hpp
new file mode 100644
index 0000000000..43452da5fe
--- /dev/null
+++ b/ext/boost/serialization/shared_ptr.hpp
@@ -0,0 +1,159 @@
+#ifndef BOOST_SERIALIZATION_SHARED_PTR_HPP
+#define BOOST_SERIALIZATION_SHARED_PTR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// shared_ptr.hpp: serialization for boost shared pointer
+
+// (C) Copyright 2004 Robert Ramey and Martin Ecker
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <map>
+#include <cstddef> // NULL
+
+#include <boost/config.hpp>
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/detail/workaround.hpp>
+#include <boost/shared_ptr.hpp>
+
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/tracking.hpp>
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// shared_ptr serialization traits
+// version 1 to distinguish from boost 1.32 version. Note: we can only do this
+// for a template when the compiler supports partial template specialization
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    namespace boost {
+    namespace serialization{
+        template<class T>
+        struct version< ::boost::shared_ptr<T> > {
+            typedef mpl::integral_c_tag tag;
+            #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
+            typedef BOOST_DEDUCED_TYPENAME mpl::int_<1> type;
+            #else
+            typedef mpl::int_<1> type;
+            #endif
+            #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570))
+            BOOST_STATIC_CONSTANT(unsigned int, value = 1);
+            #else
+            BOOST_STATIC_CONSTANT(unsigned int, value = type::value);
+            #endif
+        };
+        // don't track shared pointers
+        template<class T>
+        struct tracking_level< ::boost::shared_ptr<T> > { 
+            typedef mpl::integral_c_tag tag;
+            #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
+            typedef BOOST_DEDUCED_TYPENAME mpl::int_< ::boost::serialization::track_never> type;
+            #else
+            typedef mpl::int_< ::boost::serialization::track_never> type;
+            #endif
+            #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570))
+            BOOST_STATIC_CONSTANT(int, value = ::boost::serialization::track_never);
+            #else
+            BOOST_STATIC_CONSTANT(int, value = type::value);
+            #endif
+        };
+    }}
+    #define BOOST_SERIALIZATION_SHARED_PTR(T)
+#else
+    // define macro to let users of these compilers do this
+    #define BOOST_SERIALIZATION_SHARED_PTR(T)                         \
+    BOOST_CLASS_VERSION(                                              \
+        ::boost::shared_ptr< T >,                                     \
+        1                                                             \
+    )                                                                 \
+    BOOST_CLASS_TRACKING(                                             \
+        ::boost::shared_ptr< T >,                                     \
+        ::boost::serialization::track_never                           \
+    )                                                                 \
+    /**/
+#endif
+
+namespace boost {
+namespace serialization{
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization for shared_ptr
+
+template<class Archive, class T>
+inline void save(
+    Archive & ar,
+    const boost::shared_ptr<T> &t,
+    const unsigned int /* file_version */
+){
+    // The most common cause of trapping here would be serializing
+    // something like shared_ptr<int>.  This occurs because int
+    // is never tracked by default.  Wrap int in a trackable type
+    BOOST_STATIC_ASSERT((tracking_level<T>::value != track_never));
+    const T * t_ptr = t.get();
+    ar << boost::serialization::make_nvp("px", t_ptr);
+}
+
+template<class Archive, class T>
+inline void load(
+    Archive & ar,
+    boost::shared_ptr<T> &t,
+    const unsigned int file_version
+){
+    // The most common cause of trapping here would be serializing
+    // something like shared_ptr<int>.  This occurs because int
+    // is never tracked by default.  Wrap int in a trackable type
+    BOOST_STATIC_ASSERT((tracking_level<T>::value != track_never));
+    T* r;
+    #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
+    if(file_version < 1){
+        //ar.register_type(static_cast<
+        //    boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter<T> > *
+        //>(NULL));
+        ar.register_type(static_cast<
+            boost_132::detail::sp_counted_base_impl<T *, boost::archive::detail::null_deleter > *
+        >(NULL));
+        boost_132::shared_ptr<T> sp;
+        ar >> boost::serialization::make_nvp("px", sp.px);
+        ar >> boost::serialization::make_nvp("pn", sp.pn);
+        // got to keep the sps around so the sp.pns don't disappear
+        ar.append(sp);
+        r = sp.get();
+    }
+    else    
+    #endif
+    {
+        ar >> boost::serialization::make_nvp("px", r);
+    }
+    ar.reset(t,r);
+}
+
+template<class Archive, class T>
+inline void serialize(
+    Archive & ar,
+    boost::shared_ptr<T> &t,
+    const unsigned int file_version
+){
+    // correct shared_ptr serialization depends upon object tracking
+    // being used.
+    BOOST_STATIC_ASSERT(
+        boost::serialization::tracking_level<T>::value
+        != boost::serialization::track_never
+    );
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_SHARED_PTR_HPP
diff --git a/ext/boost/serialization/shared_ptr_132.hpp b/ext/boost/serialization/shared_ptr_132.hpp
new file mode 100644
index 0000000000..f0c3113994
--- /dev/null
+++ b/ext/boost/serialization/shared_ptr_132.hpp
@@ -0,0 +1,222 @@
+#ifndef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
+#define BOOST_SERIALIZATION_SHARED_PTR_132_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// shared_ptr.hpp: serialization for boost shared pointer
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+// note: totally unadvised hack to gain access to private variables
+// in shared_ptr and shared_count. Unfortunately its the only way to
+// do this without changing shared_ptr and shared_count
+// the best we can do is to detect a conflict here
+#include <boost/config.hpp>
+
+#include <list>
+#include <cstddef> // NULL
+
+#include <boost/serialization/assume_abstract.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/void_cast.hpp>
+
+// mark base class as an (uncreatable) base class
+#include <boost/serialization/detail/shared_ptr_132.hpp>
+
+/////////////////////////////////////////////////////////////
+// Maintain a couple of lists of loaded shared pointers of the old previous
+// version (1.32)
+
+namespace boost_132 { 
+namespace serialization {
+namespace detail {
+
+struct null_deleter {
+    void operator()(void const *) const {}
+};
+
+} // namespace detail
+} // namespace serialization
+} // namespace boost_132
+
+/////////////////////////////////////////////////////////////
+// sp_counted_base_impl serialization
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class P, class D>
+inline void serialize(
+    Archive & /* ar */,
+    boost_132::detail::sp_counted_base_impl<P, D> & /* t */,
+    const unsigned int /*file_version*/
+){
+    // register the relationship between each derived class
+    // its polymorphic base
+    boost::serialization::void_cast_register<
+        boost_132::detail::sp_counted_base_impl<P, D>,
+        boost_132::detail::sp_counted_base 
+    >(
+        static_cast<boost_132::detail::sp_counted_base_impl<P, D> *>(NULL),
+        static_cast<boost_132::detail::sp_counted_base *>(NULL)
+    );
+}
+
+template<class Archive, class P, class D>
+inline void save_construct_data(
+    Archive & ar,
+    const 
+    boost_132::detail::sp_counted_base_impl<P, D> *t, 
+    const BOOST_PFTO unsigned int /* file_version */
+){
+    // variables used for construction
+    ar << boost::serialization::make_nvp("ptr", t->ptr);
+}
+
+template<class Archive, class P, class D>
+inline void load_construct_data(
+    Archive & ar,
+    boost_132::detail::sp_counted_base_impl<P, D> * t, 
+    const unsigned int /* file_version */
+){
+    P ptr_;
+    ar >> boost::serialization::make_nvp("ptr", ptr_);
+    // ::new(t)boost_132::detail::sp_counted_base_impl<P, D>(ptr_,  D()); 
+    // placement
+    // note: the original ::new... above is replaced by the one here.  This one
+    // creates all new objects with a null_deleter so that after the archive
+    // is finished loading and the shared_ptrs are destroyed - the underlying
+    // raw pointers are NOT deleted.  This is necessary as they are used by the 
+    // new system as well.
+    ::new(t)boost_132::detail::sp_counted_base_impl<
+        P, 
+        boost_132::serialization::detail::null_deleter
+    >(
+        ptr_,  boost_132::serialization::detail::null_deleter()
+    ); // placement new
+    // compensate for that fact that a new shared count always is 
+    // initialized with one. the add_ref_copy below will increment it
+    // every time its serialized so without this adjustment
+    // the use and weak counts will be off by one.
+    t->use_count_ = 0;
+}
+
+} // serialization
+} // namespace boost
+
+/////////////////////////////////////////////////////////////
+// shared_count serialization
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive>
+inline void save(
+    Archive & ar,
+    const boost_132::detail::shared_count &t,
+    const unsigned int /* file_version */
+){
+    ar << boost::serialization::make_nvp("pi", t.pi_);
+}
+
+template<class Archive>
+inline void load(
+    Archive & ar,
+    boost_132::detail::shared_count &t,
+    const unsigned int /* file_version */
+){
+    ar >> boost::serialization::make_nvp("pi", t.pi_);
+    if(NULL != t.pi_)
+        t.pi_->add_ref_copy();
+}
+
+} // serialization
+} // namespace boost
+
+BOOST_SERIALIZATION_SPLIT_FREE(boost_132::detail::shared_count)
+
+/////////////////////////////////////////////////////////////
+// implement serialization for shared_ptr<T>
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class T>
+inline void save(
+    Archive & ar,
+    const boost_132::shared_ptr<T> &t,
+    const unsigned int /* file_version */
+){
+    // only the raw pointer has to be saved
+    // the ref count is maintained automatically as shared pointers are loaded
+    ar.register_type(static_cast<
+        boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter<T> > *
+    >(NULL));
+    ar << boost::serialization::make_nvp("px", t.px);
+    ar << boost::serialization::make_nvp("pn", t.pn);
+}
+
+template<class Archive, class T>
+inline void load(
+    Archive & ar,
+    boost_132::shared_ptr<T> &t,
+    const unsigned int /* file_version */
+){
+    // only the raw pointer has to be saved
+    // the ref count is maintained automatically as shared pointers are loaded
+    ar.register_type(static_cast<
+        boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter<T> > *
+    >(NULL));
+    ar >> boost::serialization::make_nvp("px", t.px);
+    ar >> boost::serialization::make_nvp("pn", t.pn);
+}
+
+template<class Archive, class T>
+inline void serialize(
+    Archive & ar,
+    boost_132::shared_ptr<T> &t,
+    const unsigned int file_version
+){
+    // correct shared_ptr serialization depends upon object tracking
+    // being used.
+    BOOST_STATIC_ASSERT(
+        boost::serialization::tracking_level<T>::value
+        != boost::serialization::track_never
+    );
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // serialization
+} // namespace boost
+
+// note: change below uses null_deleter 
+// This macro is used to export GUIDS for shared pointers to allow
+// the serialization system to export them properly. David Tonge
+#define BOOST_SHARED_POINTER_EXPORT_GUID(T, K)                     \
+    typedef boost_132::detail::sp_counted_base_impl<               \
+        T *,                                                       \
+        boost::checked_deleter< T >                                \
+    > __shared_ptr_ ## T;                                          \
+    BOOST_CLASS_EXPORT_GUID(__shared_ptr_ ## T, "__shared_ptr_" K) \
+    BOOST_CLASS_EXPORT_GUID(T, K)                                  \
+    /**/
+
+#define BOOST_SHARED_POINTER_EXPORT(T)                             \
+    BOOST_SHARED_POINTER_EXPORT_GUID(                              \
+        T,                                                         \
+        BOOST_PP_STRINGIZE(T)                                      \
+    )                                                              \
+    /**/
+
+#endif // BOOST_SERIALIZATION_SHARED_PTR_132_HPP
diff --git a/ext/boost/serialization/singleton.hpp b/ext/boost/serialization/singleton.hpp
new file mode 100644
index 0000000000..cca3b3eb00
--- /dev/null
+++ b/ext/boost/serialization/singleton.hpp
@@ -0,0 +1,147 @@
+#ifndef BOOST_SERIALIZATION_SINGLETON_HPP
+#define BOOST_SERIALIZATION_SINGLETON_HPP
+
+/////////1/////////2///////// 3/////////4/////////5/////////6/////////7/////////8
+//  singleton.hpp
+//
+// Copyright David Abrahams 2006. Original version
+//
+// Copyright Robert Ramey 2007.  Changes made to permit
+// application throughout the serialization library.
+//
+// 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)
+//
+// The intention here is to define a template which will convert
+// any class into a singleton with the following features:
+//
+// a) initialized before first use.
+// b) thread-safe for const access to the class
+// c) non-locking
+//
+// In order to do this,
+// a) Initialize dynamically when used.
+// b) Require that all singletons be initialized before main
+// is called or any entry point into the shared library is invoked.
+// This guarentees no race condition for initialization.
+// In debug mode, we assert that no non-const functions are called
+// after main is invoked.
+//
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif 
+
+#include <cassert>
+#include <boost/noncopyable.hpp>
+#include <boost/serialization/force_include.hpp>
+
+namespace boost { 
+namespace serialization { 
+
+//////////////////////////////////////////////////////////////////////
+// Provides a dynamically-initialized (singleton) instance of T in a
+// way that avoids LNK1179 on vc6.  See http://tinyurl.com/ljdp8 or
+// http://lists.boost.org/Archives/boost/2006/05/105286.php for
+// details.
+//
+
+// singletons created by this code are guarenteed to be unique
+// within the executable or shared library which creates them.
+// This is sufficient and in fact ideal for the serialization library.
+// The singleton is created when the module is loaded and destroyed
+// when the module is unloaded.
+
+// This base class has two functions.
+
+// First it provides a module handle for each singleton indicating
+// the executable or shared library in which it was created. This
+// turns out to be necessary and sufficient to implement the tables
+// used by serialization library.
+
+// Second, it provides a mechanism to detect when a non-const function
+// is called after initialization.
+
+// make a singleton to lock/unlock all singletons for alteration.
+// The intent is that all singletons created/used by this code
+// are to be initialized before main is called. A test program
+// can lock all the singletons when main is entereed.  This any
+// attempt to retieve a mutable instances while locked will
+// generate a assertion if compiled for debug.
+
+class singleton_module  : public boost::noncopyable
+{
+private:
+    static bool & get_lock(){
+        static bool lock = false;
+        return lock;
+    }
+public:
+//    static const void * get_module_handle(){
+//        return static_cast<const void *>(get_module_handle);
+//    }
+    static void lock(){
+        get_lock() = true;
+    }
+    static void unlock(){
+        get_lock() = false;
+    }
+    static bool is_locked() {
+        return get_lock();
+    }
+};
+
+namespace detail {
+
+template<class T>
+class singleton_wrapper : public T
+{
+public:
+    static bool m_is_destroyed;
+    ~singleton_wrapper(){
+        m_is_destroyed = true;
+    }
+};
+
+template<class T>
+bool detail::singleton_wrapper<T>::m_is_destroyed = false;
+
+} // detail
+
+template <class T>
+class singleton : public singleton_module
+{
+private:
+    BOOST_DLLEXPORT static T & instance;
+    // include this to provoke instantiation at pre-execution time
+    static void use(T const &) {}
+    BOOST_DLLEXPORT static T & get_instance() {
+        static detail::singleton_wrapper<T> t;
+        // refer to instance, causing it to be instantiated (and
+        // initialized at startup on working compilers)
+        assert(! detail::singleton_wrapper<T>::m_is_destroyed);
+        use(instance);
+        return static_cast<T &>(t);
+    }
+public:
+    BOOST_DLLEXPORT static T & get_mutable_instance(){
+        assert(! is_locked());
+        return get_instance();
+    }
+    BOOST_DLLEXPORT static const T & get_const_instance(){
+        return get_instance();
+    }
+    BOOST_DLLEXPORT static bool is_destroyed(){
+        return detail::singleton_wrapper<T>::m_is_destroyed;
+    }
+};
+
+template<class T>
+BOOST_DLLEXPORT T & singleton<T>::instance = singleton<T>::get_instance();
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_SINGLETON_HPP
diff --git a/ext/boost/serialization/slist.hpp b/ext/boost/serialization/slist.hpp
new file mode 100644
index 0000000000..0a03acf92b
--- /dev/null
+++ b/ext/boost/serialization/slist.hpp
@@ -0,0 +1,101 @@
+#ifndef BOOST_SERIALIZATION_SLIST_HPP
+#define BOOST_SERIALIZATION_SLIST_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// slist.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <cstddef> // size_t
+#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#ifdef BOOST_HAS_SLIST
+#include BOOST_SLIST_HEADER
+
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/nvp.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class U, class Allocator>
+inline void save(
+    Archive & ar,
+    const BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::save_collection<
+        Archive,
+        BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> 
+    >(ar, t);
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> &t,
+    const unsigned int file_version
+){
+    // retrieve number of elements
+    t.clear();
+    // retrieve number of elements
+    collection_size_type count;
+    ar >> BOOST_SERIALIZATION_NVP(count);
+    if(std::size_t(0) == count)
+        return;
+    unsigned int v;
+    if(3 < ar.get_library_version()){
+        ar >> boost::serialization::make_nvp("item_version", v);
+    }
+    boost::serialization::detail::stack_construct<Archive, U> u(ar, v);
+    ar >> boost::serialization::make_nvp("item", u.reference());
+    t.push_front(u.reference());
+    BOOST_DEDUCED_TYPENAME BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator>::iterator last;
+    last = t.begin();
+    std::size_t c = count;
+    while(--c > 0){
+        boost::serialization::detail::stack_construct<Archive, U> 
+            u(ar, file_version);
+        ar >> boost::serialization::make_nvp("item", u.reference());
+        last = t.insert_after(last, u.reference());
+        ar.reset_object_address(& (*last), & u.reference());
+    }
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U, class Allocator>
+inline void serialize(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(BOOST_STD_EXTENSION_NAMESPACE::slist)
+
+#endif  // BOOST_HAS_SLIST
+#endif  // BOOST_SERIALIZATION_SLIST_HPP
diff --git a/ext/boost/serialization/smart_cast.hpp b/ext/boost/serialization/smart_cast.hpp
new file mode 100644
index 0000000000..89a79c4068
--- /dev/null
+++ b/ext/boost/serialization/smart_cast.hpp
@@ -0,0 +1,301 @@
+#ifndef BOOST_SERIALIZATION_SMART_CAST_HPP
+#define BOOST_SERIALIZATION_SMART_CAST_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// smart_cast.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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/serialization for updates, documentation, and revision history.
+
+// casting of pointers and references.  
+
+// In casting between different C++ classes, there are a number of
+// rules that have to be kept in mind in deciding whether to use
+// static_cast or dynamic_cast.  
+
+// a) dynamic casting can only be applied when one of the types is polymorphic
+// Otherwise static_cast must be used.
+// b) only dynamic casting can do runtime error checking
+// use of static_cast is generally un checked even when compiled for debug
+// c) static_cast would be considered faster than dynamic_cast.
+
+// If casting is applied to a template parameter, there is no apriori way
+// to know which of the two casting methods will be permitted or convenient.
+
+// smart_cast uses C++ type_traits, and program debug mode to select the
+// most convenient cast to use.
+
+#include <exception>
+#include <typeinfo>
+#include <cstddef> // NULL
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/identity.hpp>
+
+namespace boost {
+namespace serialization {
+namespace smart_cast_impl {
+
+    template<class T>
+    struct reference {
+
+        struct polymorphic {
+
+            struct linear {
+                template<class U>
+                 static T cast(U & u){
+                    return static_cast<T>(u);
+                }
+            };
+
+            struct cross {
+                 template<class U>
+                static T cast(U & u){
+                    return dynamic_cast<T>(u);
+                }
+            };
+
+            template<class U>
+            static T cast(U & u){
+                // if we're in debug mode
+                #if ! defined(NDEBUG)                               \
+                || defined(__BORLANDC__) && (__BORLANDC__ <= 0x560) \
+                || defined(__MWERKS__)
+                    // do a checked dynamic cast
+                    return cross::cast(u);
+                #else
+                    // borland 5.51 chokes here so we can't use it
+                    // note: if remove_reference isn't function for these types
+                    // cross casting will be selected this will work but will
+                    // not be the most efficient method. This will conflict with
+                    // the original smart_cast motivation.
+                    typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+                            BOOST_DEDUCED_TYPENAME mpl::and_<
+                                mpl::not_<is_base_and_derived<
+                                    BOOST_DEDUCED_TYPENAME remove_reference<T>::type,
+                                    U
+                                > >,
+                                mpl::not_<is_base_and_derived<
+                                    U,
+                                    BOOST_DEDUCED_TYPENAME remove_reference<T>::type
+                                > >
+                            >,
+                            // borland chokes w/o full qualification here
+                            mpl::identity<cross>,
+                            mpl::identity<linear>
+                    >::type typex;
+                    // typex works around gcc 2.95 issue
+                    return typex::cast(u);
+                #endif
+            }
+        };
+
+        struct non_polymorphic {
+            template<class U>
+             static T cast(U & u){
+                return static_cast<T>(u);
+            }
+        };
+        template<class U>
+        static T cast(U & u){
+            #if defined(__BORLANDC__)
+                return mpl::eval_if<
+                    boost::is_polymorphic<U>,
+                    mpl::identity<polymorphic>,
+                    mpl::identity<non_polymorphic>
+                >::type::cast(u);
+            #else
+                typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+                    boost::is_polymorphic<U>,
+                    mpl::identity<polymorphic>,
+                    mpl::identity<non_polymorphic>
+                >::type typex;
+                return typex::cast(u);
+            #endif
+        }
+    };
+
+    template<class T>
+    struct pointer {
+
+        struct polymorphic {
+            // unfortunately, this below fails to work for virtual base 
+            // classes.  need has_virtual_base to do this.
+            // Subject for further study
+            #if 0
+            struct linear {
+                template<class U>
+                 static T cast(U * u){
+                    return static_cast<T>(u);
+                }
+            };
+
+            struct cross {
+                template<class U>
+                static T cast(U * u){
+                    T tmp = dynamic_cast<T>(u);
+                    #ifndef NDEBUG
+                        if ( tmp == 0 ) throw std::bad_cast();
+                    #endif
+                    return tmp;
+                }
+            };
+
+            template<class U>
+            static T cast(U * u){
+                // if we're in debug mode
+                #if ! defined(NDEBUG) || defined(__BORLANDC__) && (__BORLANDC__ <= 0x560)
+                    // do a checked dynamic cast
+                    return cross::cast(u);
+                #else
+                    // borland 5.51 chokes here so we can't use it
+                    // note: if remove_pointer isn't function for these types
+                    // cross casting will be selected this will work but will
+                    // not be the most efficient method. This will conflict with
+                    // the original smart_cast motivation.
+                    typedef
+                        BOOST_DEDUCED_TYPENAME mpl::eval_if<
+                            BOOST_DEDUCED_TYPENAME mpl::and_<
+                                mpl::not_<is_base_and_derived<
+                                    BOOST_DEDUCED_TYPENAME remove_pointer<T>::type,
+                                    U
+                                > >,
+                                mpl::not_<is_base_and_derived<
+                                    U,
+                                    BOOST_DEDUCED_TYPENAME remove_pointer<T>::type
+                                > >
+                            >,
+                            // borland chokes w/o full qualification here
+                            mpl::identity<cross>,
+                            mpl::identity<linear>
+                        >::type typex;
+                    return typex::cast(u);
+                #endif
+            }
+            #else
+            template<class U>
+            static T cast(U * u){
+                T tmp = dynamic_cast<T>(u);
+                #ifndef NDEBUG
+                    if ( tmp == 0 ) throw std::bad_cast();
+                #endif
+                return tmp;
+            }
+            #endif
+        };
+
+        struct non_polymorphic {
+            template<class U>
+             static T cast(U * u){
+                return static_cast<T>(u);
+            }
+        };
+
+        template<class U>
+        static T cast(U * u){
+            #if defined(__BORLANDC__)
+                return mpl::eval_if<
+                    boost::is_polymorphic<U>,
+                    mpl::identity<polymorphic>,
+                    mpl::identity<non_polymorphic>
+                >::type::cast(u);
+            #else
+                typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+                    boost::is_polymorphic<U>,
+                    mpl::identity<polymorphic>,
+                    mpl::identity<non_polymorphic>
+                >::type typex;
+                return typex::cast(u);
+            #endif
+        }
+
+    };
+
+    template<class TPtr>
+    struct void_pointer {
+        template<class UPtr>
+        static TPtr cast(UPtr uptr){
+            return static_cast<TPtr>(uptr);
+        }
+    };
+
+    template<class T>
+    struct error {
+        // if we get here, its because we are using one argument in the
+        // cast on a system which doesn't support partial template 
+        // specialization
+        template<class U>
+        static T cast(U u){
+            BOOST_STATIC_ASSERT(sizeof(T)==0);
+            return * static_cast<T *>(NULL);
+        }
+    };
+
+} // smart_cast_impl
+
+// this implements:
+// smart_cast<Target *, Source *>(Source * s)
+// smart_cast<Target &, Source &>(s)
+// note that it will fail with
+// smart_cast<Target &>(s)
+template<class T, class U>
+T smart_cast(U u) {
+    typedef
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<
+            BOOST_DEDUCED_TYPENAME mpl::or_<
+                boost::is_same<void *, U>,
+                boost::is_same<void *, T>,
+                boost::is_same<const void *, U>,
+                boost::is_same<const void *, T>
+            >,
+            mpl::identity<smart_cast_impl::void_pointer<T> >,
+        // else
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<boost::is_pointer<U>,
+            mpl::identity<smart_cast_impl::pointer<T> >,
+        // else
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<boost::is_reference<U>,
+            mpl::identity<smart_cast_impl::reference<T> >,
+        // else
+            mpl::identity<smart_cast_impl::error<T>
+        >
+        >
+        >
+        >::type typex;
+    return typex::cast(u);
+}
+
+// this implements:
+// smart_cast_reference<Target &>(Source & s)
+template<class T, class U>
+T smart_cast_reference(U & u) {
+    return smart_cast_impl::reference<T>::cast(u);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_SMART_CAST_HPP
diff --git a/ext/boost/serialization/split_free.hpp b/ext/boost/serialization/split_free.hpp
new file mode 100644
index 0000000000..9dbcd2fd1d
--- /dev/null
+++ b/ext/boost/serialization/split_free.hpp
@@ -0,0 +1,93 @@
+#ifndef BOOST_SERIALIZATION_SPLIT_FREE_HPP
+#define BOOST_SERIALIZATION_SPLIT_FREE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// split_free.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/serialization/serialization.hpp>
+
+namespace boost {
+namespace archive {
+    namespace detail {
+        template<class Archive> class interface_oarchive;
+        template<class Archive> class interface_iarchive;
+    } // namespace detail
+} // namespace archive
+
+namespace serialization {
+
+//namespace detail {
+template<class Archive, class T>
+struct free_saver {
+    static void invoke(
+        Archive & ar, 
+        const  T & t, 
+        const unsigned int file_version
+    ){
+        // use function overload (version_type) to workaround
+        // two-phase lookup issue
+        const version_type v(file_version);
+        save(ar, t, v);
+    }
+};
+template<class Archive, class T>
+struct free_loader {
+    static void invoke(
+        Archive & ar, 
+        T & t, 
+        const unsigned int file_version
+    ){
+        // use function overload (version_type) to workaround
+        // two-phase lookup issue
+        const version_type v(file_version);
+        load(ar, t, v);
+    }
+};
+//} // namespace detail
+
+template<class Archive, class T>
+inline void split_free(
+    Archive & ar, 
+    T & t, 
+    const unsigned int file_version
+){
+    typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+        BOOST_DEDUCED_TYPENAME Archive::is_saving,
+        mpl::identity</* detail:: */ free_saver<Archive, T> >, 
+        mpl::identity</* detail:: */ free_loader<Archive, T> >
+    >::type typex;
+    typex::invoke(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#define BOOST_SERIALIZATION_SPLIT_FREE(T)       \
+namespace boost { namespace serialization {     \
+template<class Archive>                         \
+inline void serialize(                          \
+        Archive & ar,                               \
+        T & t,                                      \
+        const unsigned int file_version             \
+){                                              \
+        split_free(ar, t, file_version);            \
+}                                               \
+}}
+/**/
+
+#endif // BOOST_SERIALIZATION_SPLIT_FREE_HPP
diff --git a/ext/boost/serialization/split_member.hpp b/ext/boost/serialization/split_member.hpp
new file mode 100644
index 0000000000..69879450d8
--- /dev/null
+++ b/ext/boost/serialization/split_member.hpp
@@ -0,0 +1,86 @@
+#ifndef BOOST_SERIALIZATION_SPLIT_MEMBER_HPP
+#define BOOST_SERIALIZATION_SPLIT_MEMBER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// split_member.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+
+#include <boost/serialization/access.hpp>
+
+namespace boost {
+namespace archive {
+    namespace detail {
+        template<class Archive> class interface_oarchive;
+        template<class Archive> class interface_iarchive;
+    } // namespace detail
+} // namespace archive
+
+namespace serialization {
+namespace detail {
+
+    template<class Archive, class T>
+    struct member_saver {
+        static void invoke(
+            Archive & ar, 
+            const T & t,
+            const unsigned int file_version
+        ){
+            access::member_save(ar, t, file_version);
+        }
+    };
+
+    template<class Archive, class T>
+    struct member_loader {
+        static void invoke(
+            Archive & ar, 
+            T & t,
+            const unsigned int file_version
+        ){
+            access::member_load(ar, t, file_version);
+        }
+    };
+
+} // detail
+
+template<class Archive, class T>
+inline void split_member(
+    Archive & ar, T & t, const unsigned int file_version
+){
+    typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+        BOOST_DEDUCED_TYPENAME Archive::is_saving,
+        mpl::identity<detail::member_saver<Archive, T> >, 
+        mpl::identity<detail::member_loader<Archive, T> >
+    >::type typex;
+    typex::invoke(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+// split member function serialize funcition into save/load
+#define BOOST_SERIALIZATION_SPLIT_MEMBER()                       \
+template<class Archive>                                          \
+void serialize(                                                  \
+    Archive &ar,                                                 \
+    const unsigned int file_version                              \
+){                                                               \
+    boost::serialization::split_member(ar, *this, file_version); \
+}                                                                \
+/**/
+
+#endif // BOOST_SERIALIZATION_SPLIT_MEMBER_HPP
diff --git a/ext/boost/serialization/state_saver.hpp b/ext/boost/serialization/state_saver.hpp
new file mode 100644
index 0000000000..76bb4d6a50
--- /dev/null
+++ b/ext/boost/serialization/state_saver.hpp
@@ -0,0 +1,96 @@
+#ifndef BOOST_SERIALIZATION_STATE_SAVER_HPP
+#define BOOST_SERIALIZATION_STATE_SAVER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// state_saver.hpp:
+
+// (C) Copyright 2003-4 Pavel Vozenilek and Robert Ramey - http://www.rrsd.com.
+// Use, modification and distribution is subject to 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/serialization for updates, documentation, and revision history.
+
+// Inspired by Daryle Walker's iostate_saver concept.  This saves the original
+// value of a variable when a state_saver is constructed and restores
+// upon destruction.  Useful for being sure that state is restored to
+// variables upon exit from scope.
+
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_EXCEPTIONS
+    #include <exception>
+#endif
+
+#include <boost/call_traits.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/type_traits/has_nothrow_copy.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<class T>
+// T requirements:
+//  - POD or object semantic (cannot be reference, function, ...)
+//  - copy constructor
+//  - operator = (no-throw one preferred)
+class state_saver : private boost::noncopyable
+{
+private:
+    const T previous_value;
+    T & previous_ref;
+
+    struct restore {
+        static void invoke(T & previous_ref, const T & previous_value){
+            previous_ref = previous_value; // won't throw
+        }
+    };
+
+    struct restore_with_exception {
+        static void invoke(T & previous_ref, const T & previous_value){
+            BOOST_TRY{
+                previous_ref = previous_value;
+            } 
+            BOOST_CATCH(::std::exception &) { 
+                // we must ignore it - we are in destructor
+            }
+            BOOST_CATCH_END
+        }
+    };
+
+public:
+    state_saver(
+        T & object
+    ) : 
+        previous_value(object),
+        previous_ref(object) 
+    {}
+    
+    ~state_saver() {
+        #ifndef BOOST_NO_EXCEPTIONS
+            typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+                has_nothrow_copy<T>,
+                mpl::identity<restore>,
+                mpl::identity<restore_with_exception>
+            >::type typex;
+            typex::invoke(previous_ref, previous_value);
+        #else
+            previous_ref = previous_value;
+        #endif
+    }
+
+}; // state_saver<>
+
+} // serialization
+} // boost
+
+#endif //BOOST_SERIALIZATION_STATE_SAVER_HPP
diff --git a/ext/boost/serialization/static_warning.hpp b/ext/boost/serialization/static_warning.hpp
new file mode 100644
index 0000000000..a18a9b121e
--- /dev/null
+++ b/ext/boost/serialization/static_warning.hpp
@@ -0,0 +1,189 @@
+#ifndef BOOST_SERIALIZATION_STATIC_WARNING_HPP
+#define BOOST_SERIALIZATION_STATIC_WARNING_HPP
+
+//  (C) Copyright Robert Ramey 2003. Jonathan Turkanis 2004.
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/libs/static_assert for documentation.
+
+/*
+ Revision history:
+   15 June  2003 - Initial version.
+   31 March 2004 - improved diagnostic messages and portability 
+                   (Jonathan Turkanis)
+   03 April 2004 - works on VC6 at class and namespace scope
+                 - ported to DigitalMars
+                 - static warnings disabled by default; when enabled,
+                   uses pragmas to enable required compiler warnings
+                   on MSVC, Intel, Metrowerks and Borland 5.x.
+                   (Jonathan Turkanis)
+   30 May 2004   - tweaked for msvc 7.1 and gcc 3.3
+                 - static warnings ENabled by default; when enabled,
+                   (Robert Ramey)
+*/
+
+#include <boost/config.hpp>
+
+//
+// Implementation
+// Makes use of the following warnings:
+//  1. GCC prior to 3.3: division by zero.
+//  2. BCC 6.0 preview: unreferenced local variable.
+//  3. DigitalMars: returning address of local automatic variable.
+//  4. VC6: class previously seen as struct (as in 'boost/mpl/print.hpp')
+//  5. All others: deletion of pointer to incomplete type.
+//
+// The trick is to find code which produces warnings containing the name of
+// a structure or variable. Details, with same numbering as above:
+// 1. static_warning_impl<B>::value is zero iff B is false, so diving an int
+//    by this value generates a warning iff B is false.
+// 2. static_warning_impl<B>::type has a constructor iff B is true, so an
+//    unreferenced variable of this type generates a warning iff B is false.
+// 3. static_warning_impl<B>::type overloads operator& to return a dynamically
+//    allocated int pointer only is B is true, so  returning the address of an
+//    automatic variable of this type generates a warning iff B is fasle.
+// 4. static_warning_impl<B>::STATIC_WARNING is decalred as a struct iff B is 
+//    false. 
+// 5. static_warning_impl<B>::type is incomplete iff B is false, so deleting a
+//    pointer to this type generates a warning iff B is false.
+//
+
+//------------------Enable selected warnings----------------------------------//
+
+// Enable the warnings relied on by BOOST_STATIC_WARNING, where possible. The 
+// only pragma which is absolutely necessary here is for Borland 5.x, since 
+// W8073 is disabled by default. If enabling selected warnings is considered 
+// unacceptable, this section can be replaced with:
+//   #if defined(__BORLANDC__) && (__BORLANDC__ <= 0x600)
+//    pragma warn +stu
+//   #endif
+
+# if defined(BOOST_MSVC)
+#  pragma warning(2:4150) // C4150: deletion of pointer to incomplete type 'type'.
+# elif defined(BOOST_INTEL) && (defined(__WIN32__) || defined(WIN32))
+#  pragma warning(2:457) // #457: delete of pointer to incomplete class.
+# elif defined(__BORLANDC__) && (__BORLANDC__ <= 0x600)
+#  pragma warn +stu  // W8073: Undefined structure 'structure'.
+# elif defined(__MWERKS__)
+#  pragma extended_errorcheck on // Enable 'extended error checking'.
+# endif
+
+//------------------Configure-------------------------------------------------//
+# if defined(BOOST_INTEL)
+# elif defined(__PGI)
+#  define BOOST_HAS_DESCRIPTIVE_DIVIDE_BY_ZERO_WARNING
+# elif defined(__GNUC__) && !defined(BOOST_INTEL) // && (__GNUC__ * 100 + __GNUC_MINOR__ <= 302)
+#  define BOOST_HAS_DESCRIPTIVE_DIVIDE_BY_ZERO_WARNING
+# elif  defined(__DECCXX) // for Tru64
+#  define BOOST_HAS_DESCRIPTIVE_DIVIDE_BY_ZERO_WARNING
+# elif defined(__DMC__)
+#  define BOOST_HAS_DESCRIPTIVE_RETURNING_ADDRESS_OF_TEMPORARY_WARNING
+# elif defined(BOOST_MSVC) // && (BOOST_MSVC < 1300)
+#  define BOOST_NO_PREDEFINED_LINE_MACRO
+#  pragma warning(disable:4094) // C4094: untagged 'struct' declared no symbols
+# else
+#  define BOOST_HAS_DESCRIPTIVE_INCOMPLETE_TYPE_WARNING
+#endif
+
+//------------------Helper templates------------------------------------------//
+
+namespace boost {
+namespace serialization {
+
+struct STATIC_WARNING;
+
+template<bool>
+struct static_warning_impl;
+
+template<>
+struct static_warning_impl<false> {
+    enum { value = 0 };
+    #if !defined(BOOST_HAS_DESCRIPTIVE_UNREFERENCED_VARIABLE_WARNING) && \
+        !defined(BOOST_HAS_DESCRIPTIVE_RETURNING_ADDRESS_OF_TEMPORARY_WARNING)
+        typedef boost::serialization::STATIC_WARNING type;
+    #else
+        typedef int type;
+    #endif
+    #if defined(BOOST_NO_PREDEFINED_LINE_MACRO)
+        struct STATIC_WARNING { };
+    #endif
+};
+
+template<>
+struct static_warning_impl<true> {
+    enum { value = 1 };
+    struct type { type() { } int* operator&() { return new int; } };
+    #if defined(BOOST_NO_PREDEFINED_LINE_MACRO)
+        class STATIC_WARNING { };
+    #endif
+};
+
+} // namespace serialization
+} // namespace boost
+
+//------------------Definition of BOOST_STATIC_WARNING------------------------//
+
+#if defined(BOOST_HAS_DESCRIPTIVE_UNREFERENCED_VARIABLE_WARNING)
+#    define BOOST_STATIC_WARNING_IMPL(B)                        \
+     struct BOOST_JOIN(STATIC_WARNING, __LINE__) {              \
+       void f() {                                               \
+           ::boost::serialization::static_warning_impl<(bool)( B )>::type      \
+           STATIC_WARNING;                                      \
+       }                                                        \
+     }                                                          \
+     /**/
+#elif defined(BOOST_HAS_DESCRIPTIVE_RETURNING_ADDRESS_OF_TEMPORARY_WARNING)
+#    define BOOST_STATIC_WARNING_IMPL(B)                        \
+     struct BOOST_JOIN(STATIC_WARNING, __LINE__) {              \
+        int* f() {                                              \
+            ::boost::serialization::static_warning_impl<(bool)( B )>::type     \
+            STATIC_WARNING;                                     \
+            return &STATIC_WARNING;                             \
+        }                                                       \
+     }                                                          \
+     /**/
+#elif defined(BOOST_HAS_DESCRIPTIVE_DIVIDE_BY_ZERO_WARNING)
+#    define BOOST_STATIC_WARNING_IMPL(B)                        \
+     struct BOOST_JOIN(STATIC_WARNING, __LINE__) {              \
+         int f() {                                              \
+            int STATIC_WARNING = 1;                             \
+            return STATIC_WARNING /                             \
+                boost::serialization::static_warning_impl<(bool)( B )>::value; } \
+     }                                                          \
+     /**/
+#elif defined(BOOST_NO_PREDEFINED_LINE_MACRO) 
+     // VC6; __LINE__ macro broken when -ZI is used see Q199057, so 
+     // non-conforming workaround is used.
+#    define BOOST_STATIC_WARNING_IMPL(B)                       \
+     struct BOOST_JOIN(STATIC_WARNING, __LINE__) {             \
+        struct S {                                             \
+            typedef boost::serialization::static_warning_impl<(bool)( B )> f; \
+            friend class f::STATIC_WARNING;                    \
+        };                                                     \
+     };                                                        \
+     /**/
+#elif defined(BOOST_HAS_DESCRIPTIVE_INCOMPLETE_TYPE_WARNING)
+#    define BOOST_STATIC_WARNING_IMPL(B)                     \
+     struct BOOST_JOIN(STATIC_WARNING, __LINE__) {           \
+         ::boost::serialization::static_warning_impl<(bool)( B )>::type* p; \
+         void f() { delete p; }                              \
+     }                                                       \
+     /**/
+#else // not defined for this compiler
+#    define BOOST_STATIC_WARNING_IMPL(B)
+#endif
+
+#ifndef BOOST_DISABLE_STATIC_WARNINGS
+# define BOOST_STATIC_WARNING(B) BOOST_STATIC_WARNING_IMPL(B)
+#else // #ifdef BOOST_ENABLE_STATIC_WARNINGS //-------------------------------//
+# define BOOST_STATIC_WARNING(B) BOOST_STATIC_WARNING_IMPL(true)
+#endif
+
+#endif // BOOST_SERIALIZATION_STATIC_WARNING_HPP
diff --git a/ext/boost/serialization/string.hpp b/ext/boost/serialization/string.hpp
new file mode 100644
index 0000000000..36d15942a8
--- /dev/null
+++ b/ext/boost/serialization/string.hpp
@@ -0,0 +1,91 @@
+#ifndef  BOOST_SERIALIZATION_STRING_HPP
+#define BOOST_SERIALIZATION_STRING_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization/string.hpp:
+// serialization for stl string templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <string>
+
+#include <boost/config.hpp>
+#include <boost/serialization/level.hpp>
+
+BOOST_CLASS_IMPLEMENTATION(std::string, boost::serialization::primitive_type)
+#ifndef BOOST_NO_STD_WSTRING
+BOOST_CLASS_IMPLEMENTATION(std::wstring, boost::serialization::primitive_type)
+#endif
+
+// left over from a previous incarnation - strings are now always primitive types
+#if 0 
+#include <string>
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost { 
+namespace serialization {
+
+// basic_string - general case
+template<class Archive, class U, class Allocator>
+inline void save(
+    Archive & ar,
+    const std::basic_string<U, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::save_collection<
+        Archive, std::basic_string<U, Allocator> 
+    >(ar, t);
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+    Archive & ar,
+    std::basic_string<U, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::load_collection<
+        Archive,
+        std::basic_string<U, Allocator>,
+        boost::serialization::stl::archive_input_seq<
+            Archive, 
+            std::basic_string<U, Allocator> 
+        >,
+        boost::serialization::stl::reserve_imp<
+            std::basic_string<U, Allocator> 
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U, class Allocator>
+inline void serialize(
+    Archive & ar,
+    std::basic_string<U, Allocator> & t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(std::vector)
+
+#endif
+
+#endif // BOOST_SERIALIZATION_STRING_HPP
diff --git a/ext/boost/serialization/strong_typedef.hpp b/ext/boost/serialization/strong_typedef.hpp
new file mode 100644
index 0000000000..647c302efb
--- /dev/null
+++ b/ext/boost/serialization/strong_typedef.hpp
@@ -0,0 +1,66 @@
+#ifndef BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP
+#define BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// strong_typedef.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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/serialization for updates, documentation, and revision history.
+
+// macro used to implement a strong typedef.  strong typedef
+// guarentees that two types are distinguised even though the
+// share the same underlying implementation.  typedef does not create
+// a new type.  BOOST_STRONG_TYPEDEF(T, D) creates a new type named D
+// that operates as a type T.
+
+#include <boost/config.hpp>
+#include <boost/operators.hpp>
+
+#if !defined(__BORLANDC__) || __BORLANDC__ >= 0x590
+    #define BOOST_STRONG_TYPEDEF(T, D)                              \
+    struct D                                                        \
+        : boost::totally_ordered1< D                                \
+        , boost::totally_ordered2< D, T                             \
+        > >                                                         \
+    {                                                               \
+        T t;                                                        \
+        explicit D(const T t_) : t(t_) {};                          \
+        D(){};                                                      \
+        D(const D & t_) : t(t_.t){}                                 \
+        D & operator=(const D & rhs) { t = rhs.t; return *this;}    \
+        D & operator=(const T & rhs) { t = rhs; return *this;}      \
+        operator const T & () const {return t; }                    \
+        operator T & () { return t; }                               \
+        bool operator==(const D & rhs) const { return t == rhs.t; } \
+        bool operator<(const D & rhs) const { return t < rhs.t; }   \
+    };
+#else
+    #define BOOST_STRONG_TYPEDEF(T, D)                              \
+    struct D                                                        \
+        : boost::totally_ordered1< D                                \
+        , boost::totally_ordered2< D, T                             \
+        > >                                                         \
+    {                                                               \
+        T t;                                                        \
+        explicit D(const T t_) : t(t_) {};                          \
+        D(){};                                                      \
+        D(const D & t_) : t(t_.t){}                                 \
+        D & operator=(const D & rhs) { t = rhs.t; return *this;}    \
+        D & operator=(const T & rhs) { t = rhs; return *this;}      \
+        /*operator const T & () const {return t; }*/                \
+        operator T & () { return t; }                               \
+        bool operator==(const D & rhs) const { return t == rhs.t; } \
+        bool operator<(const D & rhs) const { return t < rhs.t; }   \
+    };
+#endif // !defined(__BORLANDC) || __BORLANDC__ >= 0x590
+
+#endif // BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP
diff --git a/ext/boost/serialization/throw_exception.hpp b/ext/boost/serialization/throw_exception.hpp
new file mode 100644
index 0000000000..dad0efe579
--- /dev/null
+++ b/ext/boost/serialization/throw_exception.hpp
@@ -0,0 +1,44 @@
+#ifndef BOOST_SERIALIZATION_THROW_EXCEPTION_HPP_INCLUDED
+#define BOOST_SERIALIZATION_THROW_EXCEPTION_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  boost/throw_exception.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)
+
+#include <boost/config.hpp>
+
+#ifndef BOOST_NO_EXCEPTIONS
+#include <exception>
+#endif
+
+namespace boost {
+namespace serialization {
+
+#ifdef BOOST_NO_EXCEPTIONS
+
+void inline throw_exception(std::exception const & e) {
+    ::boost::throw_exception(e);
+}
+
+#else
+
+template<class E> inline void throw_exception(E const & e){
+    throw e;
+}
+
+#endif
+
+} // namespace serialization
+} // namespace boost
+
+#endif // #ifndef BOOST_SERIALIZATION_THROW_EXCEPTION_HPP_INCLUDED
diff --git a/ext/boost/serialization/tracking.hpp b/ext/boost/serialization/tracking.hpp
new file mode 100644
index 0000000000..425bb67475
--- /dev/null
+++ b/ext/boost/serialization/tracking.hpp
@@ -0,0 +1,113 @@
+#ifndef BOOST_SERIALIZATION_TRACKING_HPP
+#define BOOST_SERIALIZATION_TRACKING_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// tracking.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/mpl/greater.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking_enum.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+
+namespace boost {
+namespace serialization {
+
+struct basic_traits;
+
+// default tracking level
+template<class T>
+struct tracking_level {
+    template<class U>
+    struct traits_class_tracking {
+        typedef BOOST_DEDUCED_TYPENAME U::tracking type;
+    };
+    typedef mpl::integral_c_tag tag;
+    // note: at least one compiler complained w/o the full qualification
+    // on basic traits below
+    typedef
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<
+            is_base_and_derived<boost::serialization::basic_traits, T>,
+            traits_class_tracking<T>,
+        //else
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<
+            is_pointer<T>,
+            // pointers are not tracked by default
+            mpl::int_<track_never>,
+        //else
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<
+            // for primitives
+            BOOST_DEDUCED_TYPENAME mpl::equal_to<
+                implementation_level<T>,
+                mpl::int_<primitive_type> 
+            >,
+            // is never
+            mpl::int_<track_never>,
+            // otherwise its selective
+            mpl::int_<track_selectively>
+    >  > >::type type;
+    BOOST_STATIC_CONSTANT(int, value = tracking_level::type::value);
+};
+
+
+template<class T, enum tracking_type L>
+inline bool operator>=(tracking_level<T> t, enum tracking_type l)
+{
+    return t.value >= (int)l;
+}
+
+} // namespace serialization
+} // namespace boost
+
+
+// The STATIC_ASSERT is prevents one from setting tracking for a primitive type.  
+// This almost HAS to be an error.  Doing this will effect serialization of all 
+// char's in your program which is almost certainly what you don't want to do.  
+// If you want to track all instances of a given primitive type, You'll have to 
+// wrap it in your own type so its not a primitive anymore.  Then it will compile
+// without problem.
+#define BOOST_CLASS_TRACKING(T, E)           \
+namespace boost {                            \
+namespace serialization {                    \
+template<>                                   \
+struct tracking_level< T >                   \
+{                                            \
+    typedef mpl::integral_c_tag tag;         \
+    typedef mpl::int_< E> type;              \
+    BOOST_STATIC_CONSTANT(                   \
+        int,                                 \
+        value = tracking_level::type::value  \
+    );                                       \
+    /* tracking for a class  */              \
+    BOOST_STATIC_ASSERT((                    \
+        mpl::greater<                        \
+            /* that is a prmitive */         \
+            implementation_level< T >,       \
+            mpl::int_<primitive_type>        \
+        >::value                             \
+    ));                                      \
+};                                           \
+}}
+
+#endif // BOOST_SERIALIZATION_TRACKING_HPP
diff --git a/ext/boost/serialization/tracking_enum.hpp b/ext/boost/serialization/tracking_enum.hpp
new file mode 100644
index 0000000000..e4e4e21359
--- /dev/null
+++ b/ext/boost/serialization/tracking_enum.hpp
@@ -0,0 +1,41 @@
+#ifndef BOOST_SERIALIZATION_TRACKING_ENUM_HPP
+#define BOOST_SERIALIZATION_TRACKING_ENUM_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// tracking_enum.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+namespace boost {
+namespace serialization {
+
+// addresses of serialized objects may be tracked to avoid saving/loading
+// redundant copies.  This header defines a class trait that can be used
+// to specify when objects should be tracked
+
+// names for each tracking level
+enum tracking_type
+{
+    // never track this type
+    track_never = 0,
+    // track objects of this type if the object is serialized through a 
+    // pointer.
+    track_selectively = 1,
+    // always track this type
+    track_always = 2
+};
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_TRACKING_ENUM_HPP
diff --git a/ext/boost/serialization/traits.hpp b/ext/boost/serialization/traits.hpp
new file mode 100644
index 0000000000..da800098a2
--- /dev/null
+++ b/ext/boost/serialization/traits.hpp
@@ -0,0 +1,65 @@
+#ifndef BOOST_SERIALIZATION_TRAITS_HPP
+#define BOOST_SERIALIZATION_TRAITS_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// traits.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+// This header is used to apply serialization traits to templates.  The
+// standard system can't be used for platforms which don't support
+// Partial Templlate Specialization.  
+
+// The motivation for this is the Name-Value Pair (NVP) template.
+// it has to work the same on all platforms in order for archives
+// to be portable accross platforms.
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/serialization/level_enum.hpp>
+#include <boost/serialization/tracking_enum.hpp>
+
+namespace boost {
+namespace serialization {
+
+// common base class used to detect appended traits class
+struct basic_traits {};
+
+template <class T>
+struct extended_type_info_impl;
+
+template<
+    class T, 
+    int Level, 
+    int Tracking,
+    unsigned int Version = 0,
+    class ETII = extended_type_info_impl< T >,
+    class Wrapper = mpl::false_
+>
+struct traits : public basic_traits {
+    BOOST_STATIC_ASSERT(Version == 0 || Level >= object_class_info);
+    BOOST_STATIC_ASSERT(Tracking == track_never || Level >= object_serializable);
+    typedef BOOST_DEDUCED_TYPENAME mpl::int_<Level> level;
+    typedef BOOST_DEDUCED_TYPENAME mpl::int_<Tracking> tracking;
+    typedef BOOST_DEDUCED_TYPENAME mpl::int_<Version> version;
+    typedef ETII type_info_implementation;
+    typedef Wrapper is_wrapper;
+};
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_TRAITS_HPP
diff --git a/ext/boost/serialization/type_info_implementation.hpp b/ext/boost/serialization/type_info_implementation.hpp
new file mode 100644
index 0000000000..0dbdcd55a8
--- /dev/null
+++ b/ext/boost/serialization/type_info_implementation.hpp
@@ -0,0 +1,86 @@
+#ifndef BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP
+#define BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// type_info_implementation.hpp: interface for portable version of type_info
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/serialization/traits.hpp>
+
+namespace boost {
+namespace serialization {
+
+// note that T and const T are folded into const T so that
+// there is only one table entry per type
+template<class T>
+struct type_info_implementation {
+    template<class U>
+    struct traits_class_typeinfo_implementation {
+      typedef BOOST_DEDUCED_TYPENAME U::type_info_implementation::type type;
+    };
+    // note: at least one compiler complained w/o the full qualification
+    // on basic traits below
+    typedef 
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<
+            is_base_and_derived<boost::serialization::basic_traits, T>,
+            traits_class_typeinfo_implementation<T>,
+        //else
+            mpl::identity<
+                BOOST_DEDUCED_TYPENAME extended_type_info_impl<T>::type
+            >
+        >::type type;
+};
+
+} // namespace serialization
+} // namespace boost
+
+// define a macro to assign a particular derivation of extended_type_info
+// to a specified a class. 
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
+#define BOOST_CLASS_TYPE_INFO(T, ETI)              \
+namespace boost {                                  \
+namespace serialization {                          \
+template<>                                         \
+struct type_info_implementation< T > {             \
+    typedef const ETI type;                        \
+};                                                 \
+}                                                  \
+}                                                  \
+/**/
+#else
+#define BOOST_CLASS_TYPE_INFO(T, ETI)              \
+namespace boost {                                  \
+namespace serialization {                          \
+template<>                                         \
+struct type_info_implementation< T > {             \
+    typedef ETI type;                              \
+};                                                 \
+template<>                                         \
+struct type_info_implementation< const T > {       \
+    typedef ETI type;                              \
+};                                                 \
+}                                                  \
+}                                                  \
+/**/
+#endif
+
+#endif /// BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP
diff --git a/ext/boost/serialization/utility.hpp b/ext/boost/serialization/utility.hpp
new file mode 100644
index 0000000000..f36b50f5ac
--- /dev/null
+++ b/ext/boost/serialization/utility.hpp
@@ -0,0 +1,56 @@
+#ifndef  BOOST_SERIALIZATION_UTILITY_HPP
+#define BOOST_SERIALIZATION_UTILITY_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization/utility.hpp:
+// serialization for stl utility templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <utility>
+#include <boost/config.hpp>
+
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
+#include <boost/mpl/and.hpp>
+
+namespace boost { 
+namespace serialization {
+
+// pair
+template<class Archive, class F, class S>
+inline void serialize(
+    Archive & ar,
+    std::pair<F, S> & p,
+    const unsigned int /* file_version */
+){
+    // note: we remove any const-ness on the first argument.  The reason is that 
+    // for stl maps, the type saved is pair<const key, T).  We remove
+    // the const-ness in order to be able to load it.
+    typedef BOOST_DEDUCED_TYPENAME boost::remove_const<F>::type typef;
+    ar & boost::serialization::make_nvp("first", const_cast<typef &>(p.first));
+    ar & boost::serialization::make_nvp("second", p.second);
+}
+
+/// specialization of is_bitwise_serializable for pairs
+template <class T, class U>
+struct is_bitwise_serializable<std::pair<T,U> >
+ : public mpl::and_<is_bitwise_serializable<T>,is_bitwise_serializable<U> >
+{
+};
+
+} // serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_UTILITY_HPP
diff --git a/ext/boost/serialization/valarray.hpp b/ext/boost/serialization/valarray.hpp
new file mode 100644
index 0000000000..7a81e1da58
--- /dev/null
+++ b/ext/boost/serialization/valarray.hpp
@@ -0,0 +1,74 @@
+#ifndef BOOST_SERIALIZATION_VALARAY_HPP
+#define BOOST_SERIALIZATION_VALARAY_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// valarray.hpp: serialization for stl vector templates
+
+// (C) Copyright 2005 Matthias Troyer . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <valarray>
+#include <boost/config.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/array.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/detail/get_data.hpp>
+
+// function specializations must be defined in the appropriate
+// namespace - boost::serialization
+#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+#define STD _STLP_STD
+#else
+#define STD std
+#endif
+
+namespace boost { namespace serialization {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// valarray<T>
+
+template<class Archive, class U>
+void save( Archive & ar, const STD::valarray<U> &t, const unsigned int /*file_version*/ )
+{
+  const collection_size_type count(t.size());
+  ar << BOOST_SERIALIZATION_NVP(count);
+  if (t.size())
+    ar << make_array(detail::get_data(t), t.size());
+}
+
+
+template<class Archive, class U>
+void load( Archive & ar, STD::valarray<U> &t,  const unsigned int /*file_version*/ )
+{
+  collection_size_type count;
+  ar >> BOOST_SERIALIZATION_NVP(count);
+  t.resize(count);
+  if (t.size())
+    ar >> make_array(detail::get_data(t), t.size());
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U>
+inline void serialize( Archive & ar, STD::valarray<U> & t, const unsigned int file_version)
+{
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} } // end namespace boost::serialization
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::valarray)
+#undef STD
+
+#endif // BOOST_SERIALIZATION_VALARAY_HPP
diff --git a/ext/boost/serialization/variant.hpp b/ext/boost/serialization/variant.hpp
new file mode 100644
index 0000000000..fef50956d8
--- /dev/null
+++ b/ext/boost/serialization/variant.hpp
@@ -0,0 +1,160 @@
+#ifndef BOOST_SERIALIZATION_VARIANT_HPP
+#define BOOST_SERIALIZATION_VARIANT_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER <= 1020)
+#  pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// variant.hpp - non-intrusive serialization of variant types
+//
+// copyright (c) 2005   
+// troy d. straszheim <troy@resophonic.com>
+// http://www.resophonic.com
+//
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+//
+// thanks to Robert Ramey, Peter Dimov, and Richard Crossley.
+//
+
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/pop_front.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/empty.hpp>
+
+#include <boost/serialization/throw_exception.hpp>
+
+#include <boost/variant.hpp>
+
+#include <boost/archive/archive_exception.hpp>
+
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/serialization.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<class Archive>
+struct variant_save_visitor : boost::static_visitor<> {
+    variant_save_visitor(Archive& ar) :
+        m_ar(ar)
+    {}
+    template<class T>
+    void operator()(T const & value) const
+    {
+        m_ar << BOOST_SERIALIZATION_NVP(value);
+    }
+private:
+    Archive & m_ar;
+};
+
+template<class Archive, BOOST_VARIANT_ENUM_PARAMS(/* typename */ class T)>
+void save(
+    Archive & ar,
+    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const & v,
+    unsigned int /*version*/
+){
+    int which = v.which();
+    ar << BOOST_SERIALIZATION_NVP(which);
+    typedef BOOST_DEDUCED_TYPENAME  boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types types;
+    variant_save_visitor<Archive> visitor(ar);
+    v.apply_visitor(visitor);
+}
+
+template<class S>
+struct variant_impl {
+
+    struct load_null {
+        template<class Archive, class V>
+        static void invoke(
+            Archive & /*ar*/,
+            int /*which*/,
+            V & /*v*/,
+            const unsigned int /*version*/
+        ){}
+    };
+
+    struct load_impl {
+        template<class Archive, class V>
+        static void invoke(
+            Archive & ar,
+            int which,
+            V & v,
+            const unsigned int version
+        ){
+            if(which == 0){
+                // note: A non-intrusive implementation (such as this one)
+                // necessary has to copy the value.  This wouldn't be necessary
+                // with an implementation that de-serialized to the address of the
+                // aligned storage included in the variant.
+                typedef BOOST_DEDUCED_TYPENAME mpl::front<S>::type head_type;
+                head_type value;
+                ar >> BOOST_SERIALIZATION_NVP(value);
+                v = value;
+                ar.reset_object_address(& boost::get<head_type>(v), & value);
+                return;
+            }
+            typedef BOOST_DEDUCED_TYPENAME mpl::pop_front<S>::type type;
+            variant_impl<type>::load(ar, which - 1, v, version);
+        }
+    };
+
+    template<class Archive, class V>
+    static void load(
+        Archive & ar,
+        int which,
+        V & v,
+        const unsigned int version
+    ){
+        typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<mpl::empty<S>,
+            mpl::identity<load_null>,
+            mpl::identity<load_impl>
+        >::type typex;
+        typex::invoke(ar, which, v, version);
+    }
+
+};
+
+template<class Archive, BOOST_VARIANT_ENUM_PARAMS(/* typename */ class T)>
+void load(
+    Archive & ar, 
+    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>& v,
+    const unsigned int version
+){
+    int which;
+    typedef BOOST_DEDUCED_TYPENAME boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types types;
+    ar >> BOOST_SERIALIZATION_NVP(which);
+    if(which >=  mpl::size<types>::value)
+        // this might happen if a type was removed from the list of variant types
+        boost::serialization::throw_exception(
+            boost::archive::archive_exception(
+                boost::archive::archive_exception::unsupported_version
+            )
+        );
+    variant_impl<types>::load(ar, which, v, version);
+}
+
+template<class Archive,BOOST_VARIANT_ENUM_PARAMS(/* typename */ class T)>
+inline void serialize(
+    Archive & ar,
+    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> & v,
+    const unsigned int file_version
+){
+    split_free(ar,v,file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_VARIANT_HPP
diff --git a/ext/boost/serialization/vector.hpp b/ext/boost/serialization/vector.hpp
new file mode 100644
index 0000000000..597deed733
--- /dev/null
+++ b/ext/boost/serialization/vector.hpp
@@ -0,0 +1,204 @@
+#ifndef  BOOST_SERIALIZATION_VECTOR_HPP
+#define BOOST_SERIALIZATION_VECTOR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// vector.hpp: serialization for stl vector templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// fast array serialization (C) Copyright 2005 Matthias Troyer 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <vector>
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/array.hpp>
+#include <boost/serialization/detail/get_data.hpp>
+#include <boost/mpl/bool.hpp>
+
+// default is being compatible with version 1.34.1 files, not 1.35 files
+#ifndef BOOST_SERIALIZATION_VECTOR_VERSION
+#define BOOST_SERIALIZATION_VECTOR_VERSION 4
+#endif
+
+namespace boost { 
+namespace serialization {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// vector<T>
+
+// the default versions
+
+template<class Archive, class U, class Allocator>
+inline void save(
+    Archive & ar,
+    const std::vector<U, Allocator> &t,
+    const unsigned int /* file_version */,
+    mpl::false_
+){
+    boost::serialization::stl::save_collection<Archive, STD::vector<U, Allocator> >(
+        ar, t
+    );
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+    Archive & ar,
+    std::vector<U, Allocator> &t,
+    const unsigned int /* file_version */,
+    mpl::false_
+){
+    boost::serialization::stl::load_collection<
+        Archive,
+        std::vector<U, Allocator>,
+        boost::serialization::stl::archive_input_seq<
+            Archive, STD::vector<U, Allocator> 
+        >,
+        boost::serialization::stl::reserve_imp<STD::vector<U, Allocator> >
+    >(ar, t);
+}
+
+// the optimized versions
+
+template<class Archive, class U, class Allocator>
+inline void save(
+    Archive & ar,
+    const std::vector<U, Allocator> &t,
+    const unsigned int /* file_version */,
+    mpl::true_
+){
+    const collection_size_type count(t.size());
+    ar << BOOST_SERIALIZATION_NVP(count);
+    const unsigned int item_version = version<U>::value;
+    ar << BOOST_SERIALIZATION_NVP(item_version);
+    if (!t.empty())
+        ar << make_array(detail::get_data(t),t.size());
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+    Archive & ar,
+    std::vector<U, Allocator> &t,
+    const unsigned int /* file_version */,
+    mpl::true_
+){
+    collection_size_type count(t.size());
+    ar >> BOOST_SERIALIZATION_NVP(count);
+    t.resize(count);
+    unsigned int item_version=0;
+    if(BOOST_SERIALIZATION_VECTOR_VERSION < ar.get_library_version())
+        ar >> BOOST_SERIALIZATION_NVP(item_version);
+    if (!t.empty())
+        ar >> make_array(detail::get_data(t),t.size());
+  }
+
+// dispatch to either default or optimized versions
+
+template<class Archive, class U, class Allocator>
+inline void save(
+    Archive & ar,
+    const std::vector<U, Allocator> &t,
+    const unsigned int file_version
+){
+    typedef BOOST_DEDUCED_TYPENAME 
+    boost::serialization::use_array_optimization<Archive>::template apply<
+        BOOST_DEDUCED_TYPENAME remove_const<U>::type 
+    >::type use_optimized;
+    save(ar,t,file_version, use_optimized());
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+    Archive & ar,
+    std::vector<U, Allocator> &t,
+    const unsigned int file_version
+){
+    typedef BOOST_DEDUCED_TYPENAME 
+    boost::serialization::use_array_optimization<Archive>::template apply<
+        BOOST_DEDUCED_TYPENAME remove_const<U>::type 
+    >::type use_optimized;
+    load(ar,t,file_version, use_optimized());
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U, class Allocator>
+inline void serialize(
+    Archive & ar,
+    std::vector<U, Allocator> & t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+#if ! BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// vector<bool>
+template<class Archive, class Allocator>
+inline void save(
+    Archive & ar,
+    const std::vector<bool, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    // record number of elements
+    collection_size_type count (t.size());
+    ar << BOOST_SERIALIZATION_NVP(count);
+    std::vector<bool>::const_iterator it = t.begin();
+    while(count-- > 0){
+        bool tb = *it++;
+        ar << boost::serialization::make_nvp("item", tb);
+    }
+}
+
+template<class Archive, class Allocator>
+inline void load(
+    Archive & ar,
+    std::vector<bool, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    // retrieve number of elements
+    collection_size_type count;
+    ar >> BOOST_SERIALIZATION_NVP(count);
+    t.clear();
+    while(count-- > 0){
+        bool i;
+        ar >> boost::serialization::make_nvp("item", i);
+        t.push_back(i);
+    }
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class Allocator>
+inline void serialize(
+    Archive & ar,
+    std::vector<bool, Allocator> & t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+#endif // BOOST_WORKAROUND
+
+} // serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(std::vector)
+
+#endif // BOOST_SERIALIZATION_VECTOR_HPP
diff --git a/ext/boost/serialization/vector_135.hpp b/ext/boost/serialization/vector_135.hpp
new file mode 100644
index 0000000000..3128e9a925
--- /dev/null
+++ b/ext/boost/serialization/vector_135.hpp
@@ -0,0 +1,28 @@
+////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// vector_135.hpp: serialization for stl vector templates for compatibility
+//                 with release 1.35, which had a bug
+
+// (C) Copyright 2008 Matthias Troyer
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+
+#ifndef  BOOST_SERIALIZATION_VECTOR_135_HPP
+#define BOOST_SERIALIZATION_VECTOR_135_HPP
+
+
+
+#ifdef BOOST_SERIALIZATION_VECTOR_VERSION
+#if BOOST_SERIALIZATION_VECTOR_VERSION != 4
+#error Boost.Serialization cannot be compatible with both 1.34.1. and 1.35 files. Please include boost/serialization/vector_135.hpp before vector.hpp to be compatible with 1.35 files
+#endif
+#else
+#define BOOST_SERIALIZATION_VECTOR_VERSION 4
+#endif
+
+#include <boost/serialization/vector.hpp>
+
+#endif // BOOST_SERIALIZATION_VECTOR_135_HPP
diff --git a/ext/boost/serialization/version.hpp b/ext/boost/serialization/version.hpp
new file mode 100644
index 0000000000..5f27e9e0ab
--- /dev/null
+++ b/ext/boost/serialization/version.hpp
@@ -0,0 +1,87 @@
+#ifndef BOOST_SERIALIZATION_VERSION_HPP
+#define BOOST_SERIALIZATION_VERSION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// version.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/type_traits/is_base_and_derived.hpp>
+//#include <boost/serialization/traits.hpp>
+
+namespace boost { 
+namespace serialization {
+
+struct basic_traits;
+
+// default version number is 0. Override with higher version
+// when class definition changes.
+template<class T>
+struct version
+{
+    template<class U>
+    struct traits_class_version {
+        typedef BOOST_DEDUCED_TYPENAME U::version type;
+    };
+
+    typedef mpl::integral_c_tag tag;
+    // note: at least one compiler complained w/o the full qualification
+    // on basic traits below
+    typedef
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<
+            is_base_and_derived<boost::serialization::basic_traits,T>,
+            traits_class_version<T>,
+            mpl::int_<0>
+        >::type type;
+    BOOST_STATIC_CONSTANT(unsigned int, value = version::type::value);
+};
+
+} // namespace serialization
+} // namespace boost
+
+// specify the current version number for the class
+#define BOOST_CLASS_VERSION(T, N)                                      \
+namespace boost {                                                      \
+namespace serialization {                                              \
+template<>                                                             \
+struct version<T >                                                     \
+{                                                                      \
+    typedef mpl::int_<N> type;                                         \
+    typedef mpl::integral_c_tag tag;                                   \
+    BOOST_STATIC_CONSTANT(unsigned int, value = version::type::value); \
+    /* require that class info saved when versioning is used */        \
+    /*                                                                 \
+    BOOST_STATIC_ASSERT((                                              \
+        mpl::or_<                                                      \
+            mpl::equal_to<                                             \
+                mpl::int_<0>,                                          \
+                mpl::int_<N>                                           \
+            >,                                                         \
+            mpl::equal_to<                                             \
+                implementation_level<T>,                               \
+                mpl::int_<object_class_info>                           \
+            >                                                          \
+        >::value                                                       \
+    ));                                                                \
+    */                                                                 \
+};                                                                     \
+}                                                                      \
+}
+
+#endif // BOOST_SERIALIZATION_VERSION_HPP
diff --git a/ext/boost/serialization/void_cast.hpp b/ext/boost/serialization/void_cast.hpp
new file mode 100644
index 0000000000..21e3db5ec3
--- /dev/null
+++ b/ext/boost/serialization/void_cast.hpp
@@ -0,0 +1,274 @@
+#ifndef  BOOST_SERIALIZATION_VOID_CAST_HPP
+#define BOOST_SERIALIZATION_VOID_CAST_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// void_cast.hpp:   interface for run-time casting of void pointers.
+
+// (C) Copyright 2002-2009 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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)
+// gennadiy.rozental@tfn.com
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstddef> // for ptrdiff_t
+#include <boost/weak_ptr.hpp>
+#include <boost/noncopyable.hpp>
+
+#include <boost/serialization/config.hpp>
+#include <boost/serialization/smart_cast.hpp>
+#include <boost/serialization/singleton.hpp>
+#include <boost/serialization/force_include.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+#include <boost/serialization/extended_type_info.hpp>
+#include <boost/type_traits/is_virtual_base_of.hpp>
+
+#include <boost/config/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4251 4231 4660 4275)
+#endif
+
+namespace boost { 
+namespace serialization { 
+
+class extended_type_info;
+
+// Given a void *, assume that it really points to an instance of one type
+// and alter it so that it would point to an instance of a related type.
+// Return the altered pointer. If there exists no sequence of casts that
+// can transform from_type to to_type, return a NULL.  
+
+BOOST_SERIALIZATION_DECL(void const *)
+void_upcast(
+    extended_type_info const & derived,  
+    extended_type_info const & base, 
+    void const * const t
+);
+
+inline void *
+void_upcast(
+    extended_type_info const & derived,
+    extended_type_info const & base,
+    void * const t 
+){
+    return const_cast<void*>(void_upcast(
+        derived, 
+        base, 
+        const_cast<void const *>(t)
+    ));
+}
+
+BOOST_SERIALIZATION_DECL(void const *)
+void_downcast(
+    extended_type_info const & derived,  
+    extended_type_info const & base, 
+    void const * const t
+);
+
+inline void *
+void_downcast(
+    extended_type_info const & derived,
+    extended_type_info const & base,
+    void * const t 
+){
+    return const_cast<void*>(void_downcast(
+        derived, 
+        base, 
+        const_cast<void const *>(t)
+    ));
+}
+
+namespace void_cast_detail {
+
+class BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY()) void_caster :
+    private boost::noncopyable
+{
+    friend 
+    BOOST_SERIALIZATION_DECL(void const *)
+    boost::serialization::void_upcast(
+        extended_type_info const & derived,
+        extended_type_info const & base,
+        void const * const
+    );
+    friend 
+    BOOST_SERIALIZATION_DECL(void const *)  
+    boost::serialization::void_downcast(
+        extended_type_info const & derived,
+        extended_type_info const & base,
+        void const * const
+    );
+protected:
+    void recursive_register(bool includes_virtual_base = false) const;
+    void recursive_unregister() const;
+public:
+    // Data members
+    const extended_type_info * m_derived;
+    const extended_type_info * m_base;
+    boost::weak_ptr<const extended_type_info> m_derived_observer;
+    boost::weak_ptr<const extended_type_info> m_base_observer;
+    /*const*/ std::ptrdiff_t m_difference;
+    const bool m_heap; // allocated on the heap
+
+    // note that void_casters are keyed on value of
+    // member extended type info records - NOT their
+    // addresses.  This is necessary in order for the
+    // void cast operations to work across dll and exe
+    // module boundries.
+    bool operator<(const void_caster & rhs) const;
+
+    const void_caster & operator*(){
+        return *this;
+    }
+    // each derived class must re-implement these;
+    virtual void const * upcast(void const * const t) const = 0;
+    virtual void const * downcast(void const * const t) const = 0;
+    // Constructor
+    void_caster(
+        extended_type_info const * derived,
+        extended_type_info const * base,
+        std::ptrdiff_t difference = 0,
+        bool heap = false
+    ) :
+        m_derived(derived),
+        m_base(base),
+        m_derived_observer(derived->get_weak_ptr()),
+        m_base_observer(base->get_weak_ptr()),
+        m_difference(difference),
+        m_heap(heap)
+    {}
+    virtual ~void_caster(){}
+};
+
+template <class Derived, class Base>
+class void_caster_primitive : 
+    public void_caster
+{
+    virtual void const * downcast(void const * const t) const {
+        const Derived * d = 
+            boost::serialization::smart_cast<const Derived *, const Base *>(
+                static_cast<const Base *>(t)
+            );
+        return d;
+    }
+    virtual void const * upcast(void const * const t) const {
+        const Base * b = 
+            boost::serialization::smart_cast<const Base *, const Derived *>(
+                static_cast<const Derived *>(t)
+            );
+        return b;
+    }
+public:
+    void_caster_primitive();
+    ~void_caster_primitive();
+};
+
+template <class Derived, class Base>
+void_caster_primitive<Derived, Base>::void_caster_primitive() :
+    void_caster( 
+        & type_info_implementation<Derived>::type::get_const_instance(), 
+        & type_info_implementation<Base>::type::get_const_instance(),
+        // note:I wanted to display from 0 here, but at least one compiler
+        // treated 0 by not shifting it at all.
+        reinterpret_cast<std::ptrdiff_t>(
+            static_cast<Derived *>(
+                reinterpret_cast<Base *>(1)
+            )
+        ) - 1
+    )
+{
+    recursive_register();
+}
+
+template <class Derived, class Base>
+void_caster_primitive<Derived, Base>::~void_caster_primitive(){
+    recursive_unregister();
+}
+
+template <class Derived, class Base>
+class void_caster_virtual_base : 
+    public void_caster
+{
+public:
+    virtual void const * downcast(void const * const t) const {
+        const Derived * d = 
+            dynamic_cast<const Derived *>(
+                static_cast<const Base *>(t)
+            );
+        return d;
+    }
+    virtual void const * upcast(void const * const t) const {
+        const Base * b = 
+            dynamic_cast<const Base *>(
+                static_cast<const Derived *>(t)
+            );
+        return b;
+    }
+    void_caster_virtual_base();
+    ~void_caster_virtual_base();
+};
+
+template <class Derived, class Base>
+void_caster_virtual_base<Derived,Base>::void_caster_virtual_base() :
+    void_caster( 
+        & (type_info_implementation<Derived>::type::get_const_instance()), 
+        & (type_info_implementation<Base>::type::get_const_instance())
+    )
+{
+    recursive_register(true);
+}
+
+template <class Derived, class Base>
+void_caster_virtual_base<Derived,Base>::~void_caster_virtual_base(){
+    recursive_unregister();
+}
+
+} // void_cast_detail 
+
+// Register a base/derived pair.  This indicates that it is possible
+// to upcast a void pointer from Derived to Base and downcast a
+// void pointer from Base to Derived.  Note bogus arguments to workaround
+// bug in msvc 6.0
+template<class Derived, class Base>
+BOOST_DLLEXPORT 
+inline const void_cast_detail::void_caster & void_cast_register(
+    const Derived * dnull, 
+    const Base * bnull
+) BOOST_USED;
+
+template<class Derived, class Base>
+BOOST_DLLEXPORT 
+inline const void_cast_detail::void_caster & void_cast_register(
+    Derived const * /* dnull = NULL */, 
+    Base const * /* bnull = NULL */
+){
+    typedef
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<boost::is_virtual_base_of<Base,Derived>,
+            mpl::identity<
+                void_cast_detail::void_caster_virtual_base<Derived, Base>
+            >
+        ,// else
+            mpl::identity<
+                void_cast_detail::void_caster_primitive<Derived, Base>
+            >
+        >::type typex;
+    return singleton<typex>::get_const_instance();
+}
+
+} // namespace serialization
+} // namespace boost
+
+#ifdef BOOST_MSVC  
+#  pragma warning(pop)  
+#endif
+
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_SERIALIZATION_VOID_CAST_HPP
diff --git a/ext/boost/serialization/void_cast_fwd.hpp b/ext/boost/serialization/void_cast_fwd.hpp
new file mode 100644
index 0000000000..c94adb2ec2
--- /dev/null
+++ b/ext/boost/serialization/void_cast_fwd.hpp
@@ -0,0 +1,37 @@
+#ifndef  BOOST_SERIALIZATION_VOID_CAST_FWD_HPP
+#define BOOST_SERIALIZATION_VOID_CAST_FWD_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// void_cast_fwd.hpp:   interface for run-time casting of void pointers.
+
+// (C) Copyright 2005 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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)
+// gennadiy.rozental@tfn.com
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstddef> // NULL
+#include <boost/serialization/force_include.hpp>
+
+namespace boost {
+namespace serialization {
+namespace void_cast_detail{
+class void_caster;
+} // namespace void_cast_detail
+template<class Derived, class Base>
+BOOST_DLLEXPORT 
+inline const void_cast_detail::void_caster & void_cast_register(
+    const Derived * dnull = NULL, 
+    const Base * bnull = NULL
+) BOOST_USED;
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_VOID_CAST_HPP
diff --git a/ext/boost/serialization/weak_ptr.hpp b/ext/boost/serialization/weak_ptr.hpp
new file mode 100644
index 0000000000..a0db064c4a
--- /dev/null
+++ b/ext/boost/serialization/weak_ptr.hpp
@@ -0,0 +1,58 @@
+#ifndef BOOST_SERIALIZATION_WEAK_PTR_HPP
+#define BOOST_SERIALIZATION_WEAK_PTR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// shared_ptr.hpp: serialization for boost shared pointer
+
+// (C) Copyright 2004 Robert Ramey and Martin Ecker
+// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
+
+#include <boost/weak_ptr.hpp>
+#include <boost/serialization/shared_ptr.hpp>
+
+namespace boost {
+namespace serialization{
+
+template<class Archive, class T>
+inline void save(
+    Archive & ar,
+    const boost::weak_ptr<T> &t,
+    const unsigned int /* file_version */
+){
+    const boost::shared_ptr<T> sp = t.lock();
+        ar << boost::serialization::make_nvp("shared_ptr", sp);
+}
+
+template<class Archive, class T>
+inline void load(
+    Archive & ar,
+    boost::weak_ptr<T> &t,
+    const unsigned int /* file_version */
+){
+    boost::shared_ptr<T> sp;
+        ar >> boost::serialization::make_nvp("shared_ptr", sp);
+    t = sp;
+}
+
+template<class Archive, class T>
+inline void serialize(
+    Archive & ar,
+    boost::weak_ptr<T> &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_WEAK_PTR_HPP
diff --git a/ext/boost/serialization/wrapper.hpp b/ext/boost/serialization/wrapper.hpp
new file mode 100644
index 0000000000..ee3984df5d
--- /dev/null
+++ b/ext/boost/serialization/wrapper.hpp
@@ -0,0 +1,63 @@
+#ifndef BOOST_SERIALIZATION_WRAPPER_HPP
+#define BOOST_SERIALIZATION_WRAPPER_HPP
+
+// (C) Copyright 2005-2006 Matthias Troyer
+// Use, modification and distribution is subject to 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/serialization/traits.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/mpl/eval_if.hpp>
+
+namespace boost { namespace serialization {
+
+/// the base class for serialization wrappers
+///
+/// wrappers need to be treated differently at various places in the serialization library,
+/// e.g. saving of non-const wrappers has to be possible. Since partial specialization
+// is not supported by all compilers, we derive all wrappers from wrapper_traits. 
+
+template<
+    class T, 
+    int Level = object_serializable, 
+    int Tracking = track_never,
+    unsigned int Version = 0,
+    class ETII = extended_type_info_impl< T >
+>
+struct wrapper_traits : public traits<T,Level,Tracking,Version,ETII,mpl::true_> 
+{};
+
+/// the is_wrapper type traits class. 
+
+namespace detail {
+template <class T>
+struct is_wrapper_member
+{
+  typedef BOOST_DEDUCED_TYPENAME T::is_wrapper type;
+};
+
+}
+
+
+template<class T>
+struct is_wrapper
+ : mpl::eval_if<
+      is_base_and_derived<basic_traits,T>,
+      detail::is_wrapper_member<T>,
+      mpl::false_
+    >::type
+{};
+ 
+} } // end namespace boost::serialization
+
+// A macro to define that a class is a wrapper
+#define BOOST_CLASS_IS_WRAPPER(T)            \
+namespace boost {                            \
+namespace serialization {                    \
+template<>                                   \
+struct is_wrapper< T > : mpl::true_ {};      \
+}}                                           
+
+
+#endif //BOOST_SERIALIZATION_WRAPPER_HPP