Reimport boost/iostreams as a separate project

102 files changed, 14382 insertions, 0 deletions

diff --git a/contrib/restricted/boost/iostreams/CMakeLists.txt b/contrib/restricted/boost/iostreams/CMakeLists.txt
new file mode 100644
index 0000000000..51a3db13d5
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/CMakeLists.txt
@@ -0,0 +1,53 @@
+
+# This file was gererated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+find_package(ZLIB REQUIRED)
+
+add_library(restricted-boost-iostreams)
+target_compile_options(restricted-boost-iostreams PRIVATE
+  -DBOOST_IOSTREAMS_USE_DEPRECATED
+  -Wno-everything
+)
+target_include_directories(restricted-boost-iostreams PUBLIC
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/boost/iostreams/include
+)
+target_include_directories(restricted-boost-iostreams PRIVATE
+  ${CMAKE_SOURCE_DIR}/contrib/libs/libbz2
+)
+target_link_libraries(restricted-boost-iostreams PUBLIC
+  contrib-libs-cxxsupp
+  contrib-libs-libbz2
+  contrib-libs-lzma
+  ZLIB::ZLIB
+  restricted-boost-assert
+  restricted-boost-bind
+  restricted-boost-config
+  restricted-boost-core
+  restricted-boost-detail
+  restricted-boost-function
+  restricted-boost-integer
+  restricted-boost-iterator
+  restricted-boost-mpl
+  restricted-boost-preprocessor
+  restricted-boost-random
+  restricted-boost-range
+  restricted-boost-regex
+  restricted-boost-smart_ptr
+  restricted-boost-static_assert
+  restricted-boost-throw_exception
+  restricted-boost-type_traits
+  restricted-boost-utility
+)
+target_sources(restricted-boost-iostreams PRIVATE
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/boost/iostreams/src/bzip2.cpp
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/boost/iostreams/src/file_descriptor.cpp
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/boost/iostreams/src/gzip.cpp
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/boost/iostreams/src/lzma.cpp
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/boost/iostreams/src/mapped_file.cpp
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/boost/iostreams/src/zlib.cpp
+)
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/categories.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/categories.hpp
new file mode 100644
index 0000000000..0e84de1e98
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/categories.hpp
@@ -0,0 +1,175 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Contains category and mode tags for classifying filters, devices and 
+// standard stream and stream buffers types.
+
+#ifndef BOOST_IOSTREAMS_CATEGORIES_HPP_INCLUDED
+#define BOOST_IOSTREAMS_CATEGORIES_HPP_INCLUDED 
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+namespace boost { namespace iostreams {
+
+//------------------Tags for dispatch according to i/o mode-------------------//
+
+struct any_tag { };
+namespace detail { struct two_sequence : virtual any_tag { }; }
+namespace detail { struct random_access : virtual any_tag { }; }
+namespace detail { struct one_head : virtual any_tag { }; }
+namespace detail { struct two_head : virtual any_tag { }; }
+struct input : virtual any_tag { };
+struct output : virtual any_tag { };
+struct bidirectional : virtual input, virtual output, detail::two_sequence { };
+struct dual_use : virtual input, virtual output { }; // Pseudo-mode.
+struct input_seekable : virtual input, virtual detail::random_access { };
+struct output_seekable : virtual output, virtual detail::random_access { };
+struct seekable
+    : virtual input_seekable, 
+      virtual output_seekable,
+      detail::one_head
+    { };
+struct dual_seekable
+    : virtual input_seekable,
+      virtual output_seekable,
+      detail::two_head
+    { };  
+struct bidirectional_seekable
+    : input_seekable, output_seekable,
+      bidirectional, detail::two_head
+    { };
+
+//------------------Tags for use as i/o categories----------------------------//
+
+struct device_tag : virtual any_tag { };
+struct filter_tag : virtual any_tag { };
+
+    // 
+    // Tags for optional behavior.
+    //
+
+struct peekable_tag : virtual any_tag { };        // Devices.
+struct closable_tag : virtual any_tag { };
+struct flushable_tag : virtual any_tag { };
+struct localizable_tag : virtual any_tag { };
+struct optimally_buffered_tag : virtual any_tag { };
+struct direct_tag : virtual any_tag { };          // Devices.
+struct multichar_tag : virtual any_tag { };       // Filters.
+
+struct source_tag : device_tag, input { };
+struct sink_tag : device_tag, output { };
+struct bidirectional_device_tag : device_tag, bidirectional { };
+struct seekable_device_tag : virtual device_tag, seekable { };
+
+struct input_filter_tag : filter_tag, input { };
+struct output_filter_tag : filter_tag, output { };
+struct bidirectional_filter_tag : filter_tag, bidirectional { };
+struct seekable_filter_tag : filter_tag, seekable { };
+struct dual_use_filter_tag : filter_tag, dual_use { };
+
+struct multichar_input_filter_tag
+    : multichar_tag,
+      input_filter_tag
+    { };
+struct multichar_output_filter_tag
+    : multichar_tag,
+      output_filter_tag
+    { };
+struct multichar_bidirectional_filter_tag
+    : multichar_tag,
+      bidirectional_filter_tag
+    { };
+struct multichar_seekable_filter_tag
+    : multichar_tag,
+      seekable_filter_tag
+    { };
+struct multichar_dual_use_filter_tag 
+    : multichar_tag, 
+      dual_use_filter_tag
+    { };
+
+    //
+    // Tags for standard streams and streambufs.
+    //
+
+struct std_io_tag : virtual localizable_tag { };
+struct istream_tag
+    : virtual device_tag,
+      virtual peekable_tag,
+      virtual std_io_tag
+    { };
+struct ostream_tag
+    : virtual device_tag,
+      virtual std_io_tag
+    { };
+struct iostream_tag
+    : istream_tag,
+      ostream_tag
+    { };
+struct streambuf_tag
+    : device_tag,
+      peekable_tag,
+      std_io_tag
+    { };
+struct ifstream_tag
+    : input_seekable,
+      closable_tag,
+      istream_tag
+    { };
+struct ofstream_tag
+    : output_seekable,
+      closable_tag,
+      ostream_tag
+    { };
+struct fstream_tag
+    : seekable,
+      closable_tag,
+      iostream_tag
+    { };
+struct filebuf_tag
+    : seekable,
+      closable_tag,
+      streambuf_tag
+    { };
+struct istringstream_tag
+    : input_seekable,
+      istream_tag
+    { };
+struct ostringstream_tag
+    : output_seekable,
+      ostream_tag
+    { };
+struct stringstream_tag
+    : dual_seekable,
+      iostream_tag
+    { };
+struct stringbuf_tag
+    : dual_seekable,
+      streambuf_tag
+    { };
+struct generic_istream_tag 
+    : input_seekable,
+      istream_tag
+    { };
+struct generic_ostream_tag 
+    : output_seekable,
+      ostream_tag
+    { };
+struct generic_iostream_tag 
+    : seekable,
+      iostream_tag
+    { };
+struct generic_streambuf_tag 
+    : seekable,
+      streambuf_tag
+    { };
+
+} } // End namespaces iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_CATEGORIES_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/chain.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/chain.hpp
new file mode 100644
index 0000000000..4e108c8b09
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/chain.hpp
@@ -0,0 +1,594 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_CHAIN_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_CHAIN_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/assert.hpp>
+#include <exception>
+#include <iterator>                             // advance.
+#include <list>
+#include <memory>                               // allocator, auto_ptr or unique_ptr.
+#include <typeinfo>
+#include <stdexcept>                            // logic_error, out_of_range.
+#include <boost/checked_delete.hpp>
+#include <boost/config.hpp>                     // BOOST_MSVC, template friends,
+#include <boost/detail/workaround.hpp>          // BOOST_NESTED_TEMPLATE 
+#include <boost/iostreams/constants.hpp>
+#include <boost/iostreams/detail/access_control.hpp>
+#include <boost/iostreams/detail/char_traits.hpp>
+#include <boost/iostreams/detail/push.hpp>
+#include <boost/iostreams/detail/streambuf.hpp> // pubsync.
+#include <boost/iostreams/detail/wrap_unwrap.hpp>
+#include <boost/iostreams/device/null.hpp>
+#include <boost/iostreams/positioning.hpp>
+#include <boost/iostreams/traits.hpp>           // is_filter.
+#include <boost/iostreams/stream_buffer.hpp>
+#include <boost/next_prior.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type.hpp>
+#include <boost/iostreams/detail/execute.hpp>
+
+// Sometimes type_info objects must be compared by name. Borrowed from
+// Boost.Python and Boost.Function.
+#if defined(__GNUC__) || \
+     defined(_AIX) || \
+    (defined(__sgi) && defined(__host_mips)) || \
+    (defined(linux) && defined(__INTEL_COMPILER) && defined(__ICC)) \
+    /**/
+# include <cstring>
+# define BOOST_IOSTREAMS_COMPARE_TYPE_ID(X,Y) \
+     (std::strcmp((X).name(),(Y).name()) == 0)
+#else
+# define BOOST_IOSTREAMS_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
+#endif
+
+// Deprecated. Unused.
+#define BOOST_IOSTREAMS_COMPONENT_TYPE(chain, index) \
+    chain.component_type( index ) \
+    /**/
+
+// Deprecated. Unused.
+#define BOOST_IOSTREAMS_COMPONENT(chain, index, target) \
+    chain.component< target >( index ) \
+    /**/
+
+namespace boost { namespace iostreams {
+
+//--------------Definition of chain and wchain--------------------------------//
+
+namespace detail {
+
+template<typename Chain> class chain_client;
+
+//
+// Concept name: Chain.
+// Description: Represents a chain of stream buffers which provides access
+//     to the first buffer in the chain and sends notifications when the
+//     streambufs are added to or removed from chain.
+// Refines: Closable device with mode equal to typename Chain::mode.
+// Models: chain, converting_chain.
+// Example:
+//
+//    class chain {
+//    public:
+//        typedef xxx chain_type;
+//        typedef xxx client_type;
+//        typedef xxx mode;
+//        bool is_complete() const;                  // Ready for i/o.
+//        template<typename T>
+//        void push( const T& t,                     // Adds a stream buffer to
+//                   streamsize,                     // chain, based on t, with
+//                   streamsize );                   // given buffer and putback
+//                                                   // buffer sizes. Pass -1 to
+//                                                   // request default size.
+//    protected:
+//        void register_client(client_type* client); // Associate client.
+//        void notify();                             // Notify client.
+//    };
+//
+
+//
+// Description: Represents a chain of filters with an optional device at the
+//      end.
+// Template parameters:
+//      Self - A class deriving from the current instantiation of this template.
+//          This is an example of the Curiously Recurring Template Pattern.
+//      Ch - The character type.
+//      Tr - The character traits type.
+//      Alloc - The allocator type.
+//      Mode - A mode tag.
+//
+template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
+class chain_base {
+public:
+    typedef Ch                                     char_type;
+    BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr)
+    typedef Alloc                                  allocator_type;
+    typedef Mode                                   mode;
+    struct category
+        : Mode,
+          device_tag
+        { };
+    typedef chain_client<Self>                     client_type;
+    friend class chain_client<Self>;
+private:
+    typedef linked_streambuf<Ch>                   streambuf_type;
+    typedef std::list<streambuf_type*>             list_type;
+    typedef chain_base<Self, Ch, Tr, Alloc, Mode>  my_type;
+protected:
+    chain_base() : pimpl_(new chain_impl) { }
+    chain_base(const chain_base& rhs): pimpl_(rhs.pimpl_) { }
+public:
+
+    // dual_use is a pseudo-mode to facilitate filter writing, 
+    // not a genuine mode.
+    BOOST_STATIC_ASSERT((!is_convertible<mode, dual_use>::value));
+
+    //----------Buffer sizing-------------------------------------------------//
+
+    // Sets the size of the buffer created for the devices to be added to this
+    // chain. Does not affect the size of the buffer for devices already
+    // added.
+    void set_device_buffer_size(std::streamsize n) 
+        { pimpl_->device_buffer_size_ = n; }
+
+    // Sets the size of the buffer created for the filters to be added
+    // to this chain. Does not affect the size of the buffer for filters already
+    // added.
+    void set_filter_buffer_size(std::streamsize n) 
+        { pimpl_->filter_buffer_size_ = n; }
+
+    // Sets the size of the putback buffer for filters and devices to be added
+    // to this chain. Does not affect the size of the buffer for filters or
+    // devices already added.
+    void set_pback_size(std::streamsize n) 
+        { pimpl_->pback_size_ = n; }
+
+    //----------Device interface----------------------------------------------//
+
+    std::streamsize read(char_type* s, std::streamsize n);
+    std::streamsize write(const char_type* s, std::streamsize n);
+    std::streampos seek(stream_offset off, BOOST_IOS::seekdir way);
+
+    //----------Direct component access---------------------------------------//
+
+    const std::type_info& component_type(int n) const
+    {
+        if (static_cast<size_type>(n) >= size())
+            boost::throw_exception(std::out_of_range("bad chain offset"));
+        return (*boost::next(list().begin(), n))->component_type();
+    }
+
+    // Deprecated.
+    template<int N>
+    const std::type_info& component_type() const { return component_type(N); }
+
+    template<typename T>
+    T* component(int n) const { return component(n, boost::type<T>()); }
+
+    // Deprecated.
+    template<int N, typename T> 
+    T* component() const { return component<T>(N); }
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+    private:
+#endif
+    template<typename T>
+    T* component(int n, boost::type<T>) const
+    {
+        if (static_cast<size_type>(n) >= size())
+            boost::throw_exception(std::out_of_range("bad chain offset"));
+        streambuf_type* link = *boost::next(list().begin(), n);
+        if (BOOST_IOSTREAMS_COMPARE_TYPE_ID(link->component_type(), typeid(T)))
+            return static_cast<T*>(link->component_impl());
+        else
+            return 0;
+    }
+public:
+
+    //----------Container-like interface--------------------------------------//
+
+    typedef typename list_type::size_type size_type;
+    streambuf_type& front() { return *list().front(); }
+    BOOST_IOSTREAMS_DEFINE_PUSH(push, mode, char_type, push_impl)
+    void pop();
+    bool empty() const { return list().empty(); }
+    size_type size() const { return list().size(); }
+    void reset();
+
+    //----------Additional i/o functions--------------------------------------//
+
+    // Returns true if this chain is non-empty and its final link
+    // is a source or sink, i.e., if it is ready to perform i/o.
+    bool is_complete() const;
+    bool auto_close() const;
+    void set_auto_close(bool close);
+    bool sync() { return front().BOOST_IOSTREAMS_PUBSYNC() != -1; }
+    bool strict_sync();
+private:
+    template<typename T>
+    void push_impl(const T& t, std::streamsize buffer_size = -1, 
+                   std::streamsize pback_size = -1)
+    {
+        typedef typename iostreams::category_of<T>::type  category;
+        typedef typename unwrap_ios<T>::type              component_type;
+        typedef stream_buffer<
+                    component_type,
+                    BOOST_IOSTREAMS_CHAR_TRAITS(char_type),
+                    Alloc, Mode
+                >                                         streambuf_t;
+        typedef typename list_type::iterator              iterator;
+        BOOST_STATIC_ASSERT((is_convertible<category, Mode>::value));
+        if (is_complete())
+            boost::throw_exception(std::logic_error("chain complete"));
+        streambuf_type* prev = !empty() ? list().back() : 0;
+        buffer_size =
+            buffer_size != -1 ?
+                buffer_size :
+                iostreams::optimal_buffer_size(t);
+        pback_size =
+            pback_size != -1 ?
+                pback_size :
+                pimpl_->pback_size_;
+                
+#if defined(BOOST_NO_CXX11_SMART_PTR)
+
+        std::auto_ptr<streambuf_t>
+            buf(new streambuf_t(t, buffer_size, pback_size));
+            
+#else
+
+        std::unique_ptr<streambuf_t>
+            buf(new streambuf_t(t, buffer_size, pback_size));
+            
+#endif
+            
+        list().push_back(buf.get());
+        buf.release();
+        if (is_device<component_type>::value) {
+            pimpl_->flags_ |= f_complete | f_open;
+            for ( iterator first = list().begin(),
+                           last = list().end();
+                  first != last;
+                  ++first )
+            {
+                (*first)->set_needs_close();
+            }
+        }
+        if (prev) prev->set_next(list().back());
+        notify();
+    }
+
+    list_type& list() { return pimpl_->links_; }
+    const list_type& list() const { return pimpl_->links_; }
+    void register_client(client_type* client) { pimpl_->client_ = client; }
+    void notify() { if (pimpl_->client_) pimpl_->client_->notify(); }
+
+    //----------Nested classes------------------------------------------------//
+
+    static void close(streambuf_type* b, BOOST_IOS::openmode m)
+    {
+        if (m == BOOST_IOS::out && is_convertible<Mode, output>::value)
+            b->BOOST_IOSTREAMS_PUBSYNC();
+        b->close(m);
+    }
+
+    static void set_next(streambuf_type* b, streambuf_type* next)
+    { b->set_next(next); }
+
+    static void set_auto_close(streambuf_type* b, bool close)
+    { b->set_auto_close(close); }
+
+    struct closer {
+        typedef streambuf_type* argument_type;
+        typedef void result_type;
+        closer(BOOST_IOS::openmode m) : mode_(m) { }
+        void operator() (streambuf_type* b)
+        {
+            close(b, mode_);
+        }
+        BOOST_IOS::openmode mode_;
+    };
+    friend struct closer;
+
+    enum flags {
+        f_complete = 1,
+        f_open = 2,
+        f_auto_close = 4
+    };
+
+    struct chain_impl {
+        chain_impl()
+            : client_(0), device_buffer_size_(default_device_buffer_size),
+              filter_buffer_size_(default_filter_buffer_size),
+              pback_size_(default_pback_buffer_size),
+              flags_(f_auto_close)
+            { }
+        ~chain_impl()
+            {
+                try { close(); } catch (...) { }
+                try { reset(); } catch (...) { }
+            }
+        void close()
+            {
+                if ((flags_ & f_open) != 0) {
+                    flags_ &= ~f_open;
+                    stream_buffer< basic_null_device<Ch, Mode> > null;
+                    if ((flags_ & f_complete) == 0) {
+                        null.open(basic_null_device<Ch, Mode>());
+                        set_next(links_.back(), &null);
+                    }
+                    links_.front()->BOOST_IOSTREAMS_PUBSYNC();
+                    try {
+                        boost::iostreams::detail::execute_foreach(
+                            links_.rbegin(), links_.rend(), 
+                            closer(BOOST_IOS::in)
+                        );
+                    } catch (...) {
+                        try {
+                            boost::iostreams::detail::execute_foreach(
+                                links_.begin(), links_.end(), 
+                                closer(BOOST_IOS::out)
+                            );
+                        } catch (...) { }
+                        throw;
+                    }
+                    boost::iostreams::detail::execute_foreach(
+                        links_.begin(), links_.end(), 
+                        closer(BOOST_IOS::out)
+                    );
+                }
+            }
+        void reset()
+            {
+                typedef typename list_type::iterator iterator;
+                for ( iterator first = links_.begin(),
+                               last = links_.end();
+                      first != last;
+                      ++first )
+                {
+                    if ( (flags_ & f_complete) == 0 ||
+                         (flags_ & f_auto_close) == 0 )
+                    {
+                        set_auto_close(*first, false);
+                    }
+                    streambuf_type* buf = 0;
+                    std::swap(buf, *first);
+                    delete buf;
+                }
+                links_.clear();
+                flags_ &= ~f_complete;
+                flags_ &= ~f_open;
+            }
+        list_type        links_;
+        client_type*     client_;
+        std::streamsize  device_buffer_size_,
+                         filter_buffer_size_,
+                         pback_size_;
+        int              flags_;
+    };
+    friend struct chain_impl;
+
+    //----------Member data---------------------------------------------------//
+
+private:
+    shared_ptr<chain_impl> pimpl_;
+};
+
+} // End namespace detail.
+
+//
+// Macro: BOOST_IOSTREAMS_DECL_CHAIN(name, category)
+// Description: Defines a template derived from chain_base appropriate for a
+//      particular i/o category. The template has the following parameters:
+//      Ch - The character type.
+//      Tr - The character traits type.
+//      Alloc - The allocator type.
+// Macro parameters:
+//      name_ - The name of the template to be defined.
+//      category_ - The i/o category of the template to be defined.
+//
+#define BOOST_IOSTREAMS_DECL_CHAIN(name_, default_char_) \
+    template< typename Mode, typename Ch = default_char_, \
+              typename Tr = BOOST_IOSTREAMS_CHAR_TRAITS(Ch), \
+              typename Alloc = std::allocator<Ch> > \
+    class name_ : public boost::iostreams::detail::chain_base< \
+                            name_<Mode, Ch, Tr, Alloc>, \
+                            Ch, Tr, Alloc, Mode \
+                         > \
+    { \
+    public: \
+        struct category : device_tag, Mode { }; \
+        typedef Mode                                   mode; \
+    private: \
+        typedef boost::iostreams::detail::chain_base< \
+                    name_<Mode, Ch, Tr, Alloc>, \
+                    Ch, Tr, Alloc, Mode \
+                >                                      base_type; \
+    public: \
+        typedef Ch                                     char_type; \
+        typedef Tr                                     traits_type; \
+        typedef typename traits_type::int_type         int_type; \
+        typedef typename traits_type::off_type         off_type; \
+        name_() { } \
+        name_(const name_& rhs) : base_type(rhs) { } \
+        name_& operator=(const name_& rhs) \
+        { base_type::operator=(rhs); return *this; } \
+    }; \
+    /**/
+BOOST_IOSTREAMS_DECL_CHAIN(chain, char)
+BOOST_IOSTREAMS_DECL_CHAIN(wchain, wchar_t)
+#undef BOOST_IOSTREAMS_DECL_CHAIN
+
+//--------------Definition of chain_client------------------------------------//
+
+namespace detail {
+
+//
+// Template name: chain_client
+// Description: Class whose instances provide access to an underlying chain
+//      using an interface similar to the chains.
+// Subclasses: the various stream and stream buffer templates.
+//
+template<typename Chain>
+class chain_client {
+public:
+    typedef Chain                             chain_type;
+    typedef typename chain_type::char_type    char_type;
+    typedef typename chain_type::traits_type  traits_type;
+    typedef typename chain_type::size_type    size_type;
+    typedef typename chain_type::mode         mode;
+
+    chain_client(chain_type* chn = 0) : chain_(chn ) { }
+    chain_client(chain_client* client) : chain_(client->chain_) { }
+    virtual ~chain_client() { }
+
+    const std::type_info& component_type(int n) const
+    { return chain_->component_type(n); }
+
+    // Deprecated.
+    template<int N>
+    const std::type_info& component_type() const
+    { return chain_->BOOST_NESTED_TEMPLATE component_type<N>(); }
+
+    template<typename T>
+    T* component(int n) const
+    { return chain_->BOOST_NESTED_TEMPLATE component<T>(n); }
+
+    // Deprecated.
+    template<int N, typename T>
+    T* component() const
+    { return chain_->BOOST_NESTED_TEMPLATE component<N, T>(); }
+
+    bool is_complete() const { return chain_->is_complete(); }
+    bool auto_close() const { return chain_->auto_close(); }
+    void set_auto_close(bool close) { chain_->set_auto_close(close); }
+    bool strict_sync() { return chain_->strict_sync(); }
+    void set_device_buffer_size(std::streamsize n)
+        { chain_->set_device_buffer_size(n); }
+    void set_filter_buffer_size(std::streamsize n)
+        { chain_->set_filter_buffer_size(n); }
+    void set_pback_size(std::streamsize n) { chain_->set_pback_size(n); }
+    BOOST_IOSTREAMS_DEFINE_PUSH(push, mode, char_type, push_impl)
+    void pop() { chain_->pop(); }
+    bool empty() const { return chain_->empty(); }
+    size_type size() const { return chain_->size(); }
+    void reset() { chain_->reset(); }
+
+    // Returns a copy of the underlying chain.
+    chain_type filters() { return *chain_; }
+    chain_type filters() const { return *chain_; }
+protected:
+    template<typename T>
+    void push_impl(const T& t BOOST_IOSTREAMS_PUSH_PARAMS())
+    { chain_->push(t BOOST_IOSTREAMS_PUSH_ARGS()); }
+    chain_type& ref() { return *chain_; }
+    void set_chain(chain_type* c)
+    { chain_ = c; chain_->register_client(this); }
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) && \
+    (!BOOST_WORKAROUND(__BORLANDC__, < 0x600))
+    template<typename S, typename C, typename T, typename A, typename M>
+    friend class chain_base;
+#else
+    public:
+#endif
+    virtual void notify() { }
+private:
+    chain_type* chain_;
+};
+
+//--------------Implementation of chain_base----------------------------------//
+
+template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
+inline std::streamsize chain_base<Self, Ch, Tr, Alloc, Mode>::read
+    (char_type* s, std::streamsize n)
+{ return iostreams::read(*list().front(), s, n); }
+
+template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
+inline std::streamsize chain_base<Self, Ch, Tr, Alloc, Mode>::write
+    (const char_type* s, std::streamsize n)
+{ return iostreams::write(*list().front(), s, n); }
+
+template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
+inline std::streampos chain_base<Self, Ch, Tr, Alloc, Mode>::seek
+    (stream_offset off, BOOST_IOS::seekdir way)
+{ return iostreams::seek(*list().front(), off, way); }
+
+template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
+void chain_base<Self, Ch, Tr, Alloc, Mode>::reset()
+{
+    using namespace std;
+    pimpl_->close();
+    pimpl_->reset();
+}
+
+template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
+bool chain_base<Self, Ch, Tr, Alloc, Mode>::is_complete() const
+{
+    return (pimpl_->flags_ & f_complete) != 0;
+}
+
+template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
+bool chain_base<Self, Ch, Tr, Alloc, Mode>::auto_close() const
+{
+    return (pimpl_->flags_ & f_auto_close) != 0;
+}
+
+template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
+void chain_base<Self, Ch, Tr, Alloc, Mode>::set_auto_close(bool close)
+{
+    pimpl_->flags_ =
+        (pimpl_->flags_ & ~f_auto_close) |
+        (close ? f_auto_close : 0);
+}
+
+template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
+bool chain_base<Self, Ch, Tr, Alloc, Mode>::strict_sync()
+{
+    typedef typename list_type::iterator iterator;
+    bool result = true;
+    for ( iterator first = list().begin(),
+                   last = list().end();
+          first != last;
+          ++first )
+    {
+        bool s = (*first)->strict_sync();
+        result = result && s;
+    }
+    return result;
+}
+
+template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
+void chain_base<Self, Ch, Tr, Alloc, Mode>::pop()
+{
+    BOOST_ASSERT(!empty());
+    if (auto_close())
+        pimpl_->close();
+    streambuf_type* buf = 0;
+    std::swap(buf, list().back());
+    buf->set_auto_close(false);
+    buf->set_next(0);
+    delete buf;
+    list().pop_back();
+    pimpl_->flags_ &= ~f_complete;
+    if (auto_close() || list().empty())
+        pimpl_->flags_ &= ~f_open;
+}
+
+} // End namespace detail.
+
+} } // End namespaces iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CHAIN_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/char_traits.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/char_traits.hpp
new file mode 100644
index 0000000000..76ddf9d4f2
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/char_traits.hpp
@@ -0,0 +1,73 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_CHAR_TRAITS_HPP_INCLUDED
+#define BOOST_IOSTREAMS_CHAR_TRAITS_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif 
+
+#include <boost/config.hpp>
+#include <cstddef>
+#include <cstdio>  // EOF.
+#include <string>  // std::char_traits.
+#include <boost/iostreams/detail/char_traits.hpp>
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS
+# include <cwchar>
+#endif
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std { using ::wint_t; }
+#endif
+
+namespace boost { namespace iostreams {
+
+// Dinkumware that comes with QNX Momentics 6.3.0, 4.0.2, incorrectly defines
+// the EOF and WEOF macros to not std:: qualify the wint_t type (and so does
+// Sun C++ 5.8 + STLport 4). Fix by placing the def in this scope.
+// NOTE: Use BOOST_WORKAROUND?
+#if (defined(__QNX__) && defined(BOOST_DINKUMWARE_STDLIB))  \
+    || defined(__SUNPRO_CC)
+using ::std::wint_t;
+#endif
+
+const int WOULD_BLOCK = (int) (EOF - 1);
+
+#ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS
+const std::wint_t WWOULD_BLOCK = (std::wint_t) (WEOF - 1);
+#endif
+
+template<typename Ch>
+struct char_traits;
+
+template<>
+struct char_traits<char> : BOOST_IOSTREAMS_CHAR_TRAITS(char) {
+    static char newline() { return '\n'; }
+    static int good() { return '\n'; }
+    static int would_block() { return WOULD_BLOCK; }
+    static bool is_good(int c) { return c != EOF && c != WOULD_BLOCK; }
+    static bool is_eof(int c) { return c == EOF; }
+    static bool would_block(int c) { return c == WOULD_BLOCK; }
+};
+
+#ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS
+template<>
+struct char_traits<wchar_t> : std::char_traits<wchar_t> {
+    static wchar_t newline() { return L'\n'; }
+    static std::wint_t good() { return L'\n'; }
+    static std::wint_t would_block() { return WWOULD_BLOCK; }
+    static bool is_good(std::wint_t c) { return c != WEOF && c != WWOULD_BLOCK; }
+    static bool is_eof(std::wint_t c) { return c == WEOF; }
+    static bool would_block(std::wint_t c) { return c == WWOULD_BLOCK; }
+};
+#endif
+
+} } // End namespaces iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_CHAR_TRAITS_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/checked_operations.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/checked_operations.hpp
new file mode 100644
index 0000000000..667d925443
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/checked_operations.hpp
@@ -0,0 +1,158 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2005-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Contains implementations of get, read, put, write and seek which
+// check a device's mode at runtime instead of compile time.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_CHECKED_OPERATIONS_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_CHECKED_OPERATIONS_HPP_INCLUDED
+
+#include <boost/iostreams/categories.hpp>
+#include <boost/iostreams/detail/dispatch.hpp>
+#include <boost/iostreams/detail/error.hpp>
+#include <boost/iostreams/detail/config/unreachable_return.hpp>
+#include <boost/iostreams/get.hpp>
+#include <boost/iostreams/put.hpp>
+#include <boost/iostreams/read.hpp>
+#include <boost/iostreams/seek.hpp>
+#include <boost/iostreams/traits.hpp>
+#include <boost/iostreams/write.hpp>
+#include <boost/throw_exception.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>  // MSVC.
+
+namespace boost { namespace iostreams {
+
+namespace detail {
+
+template<typename T> 
+struct read_write_if_impl;
+
+template<typename T> 
+struct seek_if_impl;
+
+} // End namespace detail.
+
+template<typename T>
+typename int_type_of<T>::type get_if(T& t)
+{ 
+    typedef typename detail::dispatch<T, input, output>::type tag;
+    return detail::read_write_if_impl<tag>::get(t);
+}
+
+template<typename T>
+inline std::streamsize
+read_if(T& t, typename char_type_of<T>::type* s, std::streamsize n)
+{ 
+    typedef typename detail::dispatch<T, input, output>::type tag;
+    return detail::read_write_if_impl<tag>::read(t, s, n);
+}
+
+template<typename T>
+bool put_if(T& t, typename char_type_of<T>::type c)
+{ 
+    typedef typename detail::dispatch<T, output, input>::type tag;
+    return detail::read_write_if_impl<tag>::put(t, c);
+}
+
+template<typename T>
+inline std::streamsize write_if
+    (T& t, const typename char_type_of<T>::type* s, std::streamsize n)
+{ 
+    typedef typename detail::dispatch<T, output, input>::type tag;
+    return detail::read_write_if_impl<tag>::write(t, s, n);
+}
+
+template<typename T>
+inline std::streampos
+seek_if( T& t, stream_offset off, BOOST_IOS::seekdir way, 
+         BOOST_IOS::openmode which = BOOST_IOS::in | BOOST_IOS::out )
+{ 
+    using namespace detail;
+    typedef typename dispatch<T, random_access, any_tag>::type tag;
+    return seek_if_impl<tag>::seek(t, off, way, which);
+}
+
+namespace detail {
+
+//------------------Specializations of read_write_if_impl---------------------//
+
+template<>
+struct read_write_if_impl<input> {
+    template<typename T>
+    static typename int_type_of<T>::type get(T& t)
+    { return iostreams::get(t); }
+
+    template<typename T>
+    static std::streamsize
+    read(T& t, typename char_type_of<T>::type* s, std::streamsize n)
+    { return iostreams::read(t, s, n); }
+
+    template<typename T>
+    static bool put(T&, typename char_type_of<T>::type)
+    { boost::throw_exception(cant_write());
+      BOOST_IOSTREAMS_UNREACHABLE_RETURN(false) }
+
+    template<typename T>
+    static std::streamsize 
+    write(T&, const typename char_type_of<T>::type*, std::streamsize)
+    { boost::throw_exception(cant_write());
+      BOOST_IOSTREAMS_UNREACHABLE_RETURN(0) }
+};
+
+template<>
+struct read_write_if_impl<output> {
+    template<typename T>
+    static typename int_type_of<T>::type get(T&)
+    { boost::throw_exception(cant_read());
+      BOOST_IOSTREAMS_UNREACHABLE_RETURN(0) }
+
+    template<typename T>
+    static std::streamsize
+    read(T&, typename char_type_of<T>::type*, std::streamsize)
+    { boost::throw_exception(cant_read());
+      BOOST_IOSTREAMS_UNREACHABLE_RETURN(0) }
+
+    template<typename T>
+    static bool put(T& t, typename char_type_of<T>::type c)
+    { return iostreams::put(t, c); }
+
+    template<typename T>
+    static std::streamsize 
+    write( T& t, const typename char_type_of<T>::type* s, 
+           std::streamsize n )
+    { return iostreams::write(t, s, n); }
+};
+
+//------------------Specializations of seek_if_impl---------------------------//
+
+template<>
+struct seek_if_impl<random_access> {
+    template<typename T>
+    static std::streampos 
+    seek( T& t, stream_offset off, BOOST_IOS::seekdir way, 
+          BOOST_IOS::openmode which )
+    { return iostreams::seek(t, off, way, which); }
+};
+
+template<>
+struct seek_if_impl<any_tag> {
+    template<typename T>
+    static std::streampos 
+    seek(T&, stream_offset, BOOST_IOS::seekdir, BOOST_IOS::openmode)
+    { boost::throw_exception(cant_seek());
+      BOOST_IOSTREAMS_UNREACHABLE_RETURN(std::streampos()) }
+};
+
+} // End namespace detail.
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp>  // MSVC.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CHECKED_OPERATIONS_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/close.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/close.hpp
new file mode 100644
index 0000000000..8ae499ff26
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/close.hpp
@@ -0,0 +1,253 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_CLOSE_HPP_INCLUDED
+#define BOOST_IOSTREAMS_CLOSE_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp>  // DEDUCED_TYPENAME, MSVC.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/categories.hpp>
+#include <boost/iostreams/flush.hpp>
+#include <boost/iostreams/detail/adapter/non_blocking_adapter.hpp>
+#include <boost/iostreams/detail/ios.hpp> // BOOST_IOS
+#include <boost/iostreams/detail/select.hpp>
+#include <boost/iostreams/detail/wrap_unwrap.hpp>
+#include <boost/iostreams/operations_fwd.hpp>
+#include <boost/iostreams/traits.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>
+
+namespace boost { namespace iostreams {
+
+template<typename T>
+void close(T& t);
+
+template<typename T>
+void close(T& t, BOOST_IOS::openmode which);
+
+template<typename T, typename Sink>
+void close(T& t, Sink& snk, BOOST_IOS::openmode which);
+    
+namespace detail {
+
+template<typename T>
+void close_all(T& t)
+{ 
+    try {
+        boost::iostreams::close(t, BOOST_IOS::in);
+    } catch (...) {
+        try {
+            boost::iostreams::close(t, BOOST_IOS::out);
+        } catch (...) { }
+        throw;
+    }
+    boost::iostreams::close(t, BOOST_IOS::out);
+}
+
+template<typename T, typename Sink>
+void close_all(T& t, Sink& snk)
+{ 
+    try {
+        boost::iostreams::close(t, snk, BOOST_IOS::in);
+    } catch (...) {
+        try {
+            boost::iostreams::close(t, snk, BOOST_IOS::out);
+        } catch (...) { }
+        throw;
+    }
+    boost::iostreams::close(t, snk, BOOST_IOS::out);
+}
+
+} // End namespace detail. 
+
+} } // End namespaces iostreams, boost.
+
+namespace boost { namespace iostreams {
+
+namespace detail {
+
+template<typename T>
+struct close_impl;
+
+} // End namespace detail.
+
+template<typename T>
+void close(T& t) { detail::close_all(t); }
+
+template<typename T>
+void close(T& t, BOOST_IOS::openmode which)
+{ 
+#ifdef BOOST_IOSTREAMS_STRICT
+    BOOST_ASSERT(which == BOOST_IOS::in || which == BOOST_IOS::out);
+#else
+    if (which == (BOOST_IOS::in | BOOST_IOS::out)) {
+        detail::close_all(t);
+        return;
+    }
+#endif
+    detail::close_impl<T>::close(detail::unwrap(t), which); 
+}
+
+template<typename T, typename Sink>
+void close(T& t, Sink& snk, BOOST_IOS::openmode which)
+{ 
+#ifdef BOOST_IOSTREAMS_STRICT
+    BOOST_ASSERT(which == BOOST_IOS::in || which == BOOST_IOS::out);
+#else
+    if (which == (BOOST_IOS::in | BOOST_IOS::out)) {
+        detail::close_all(t, snk);
+        return;
+    }
+#endif
+    detail::close_impl<T>::close(detail::unwrap(t), snk, which); 
+}
+
+namespace detail {
+
+//------------------Definition of close_impl----------------------------------//
+
+struct close_boost_stream { };
+struct close_filtering_stream { };
+
+template<typename T>
+struct close_tag {
+    typedef typename category_of<T>::type             category;
+    typedef typename detail::unwrapped_type<T>::type  unwrapped;
+    typedef typename
+            iostreams::select<
+                mpl::not_< is_convertible<category, closable_tag> >,
+                any_tag,
+                mpl::or_<
+                    is_boost_stream<unwrapped>,
+                    is_boost_stream_buffer<unwrapped>
+                >,
+                close_boost_stream,
+                mpl::or_<
+                    is_filtering_stream<unwrapped>,
+                    is_filtering_streambuf<unwrapped>
+                >,
+                close_filtering_stream,
+                mpl::or_<
+                    is_convertible<category, two_sequence>,
+                    is_convertible<category, dual_use>
+                >,
+                two_sequence,
+                else_,
+                closable_tag
+            >::type type;
+};
+
+template<typename T>
+struct close_impl
+    : mpl::if_<
+          is_custom<T>,
+          operations<T>,
+          close_impl<BOOST_DEDUCED_TYPENAME close_tag<T>::type>
+      >::type
+    { };
+
+template<>
+struct close_impl<any_tag> {
+    template<typename T>
+    static void close(T& t, BOOST_IOS::openmode which)
+    {
+        if (which == BOOST_IOS::out)
+            iostreams::flush(t);
+    }
+
+    template<typename T, typename Sink>
+    static void close(T& t, Sink& snk, BOOST_IOS::openmode which)
+    {
+        if (which == BOOST_IOS::out) {
+            non_blocking_adapter<Sink> nb(snk);
+            iostreams::flush(t, nb);
+        }
+    }
+};
+
+template<>
+struct close_impl<close_boost_stream> {
+    template<typename T>
+    static void close(T& t)
+    {
+        t.close();
+    }
+    template<typename T>
+    static void close(T& t, BOOST_IOS::openmode which)
+    {
+        if (which == BOOST_IOS::out)
+            t.close();
+    }
+};
+
+template<>
+struct close_impl<close_filtering_stream> {
+    template<typename T>
+    static void close(T& t, BOOST_IOS::openmode which)
+    {
+        typedef typename category_of<T>::type category;
+        const bool in =  is_convertible<category, input>::value &&
+                        !is_convertible<category, output>::value;
+        if (in == (which == BOOST_IOS::in) && t.is_complete())
+            t.pop();
+    }
+};
+
+template<>
+struct close_impl<closable_tag> {
+    template<typename T>
+    static void close(T& t, BOOST_IOS::openmode which)
+    {
+        typedef typename category_of<T>::type category;
+        const bool in =  is_convertible<category, input>::value &&
+                        !is_convertible<category, output>::value;
+        if (in == (which == BOOST_IOS::in))
+            t.close();
+    }
+    template<typename T, typename Sink>
+    static void close(T& t, Sink& snk, BOOST_IOS::openmode which)
+    {
+        typedef typename category_of<T>::type category;
+        const bool in =  is_convertible<category, input>::value &&
+                        !is_convertible<category, output>::value;
+        if (in == (which == BOOST_IOS::in)) {
+            non_blocking_adapter<Sink> nb(snk);
+            t.close(nb);
+        }
+    }
+};
+
+template<>
+struct close_impl<two_sequence> {
+    template<typename T>
+    static void close(T& t, BOOST_IOS::openmode which) { t.close(which); }
+    template<typename T, typename Sink>
+    static void close(T& t, Sink& snk, BOOST_IOS::openmode which)
+    {
+        non_blocking_adapter<Sink> nb(snk);
+        t.close(nb, which);
+    }
+};
+
+} // End namespace detail.
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp>
+
+#endif // #ifndef BOOST_IOSTREAMS_CLOSE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/concepts.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/concepts.hpp
new file mode 100644
index 0000000000..da4bfd6950
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/concepts.hpp
@@ -0,0 +1,129 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_CONCEPTS_HPP_INCLUDED
+#define BOOST_IOSTREAMS_CONCEPTS_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp>  // BOOST_MSVC
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/categories.hpp>
+#include <boost/iostreams/detail/default_arg.hpp>
+#include <boost/iostreams/detail/ios.hpp>  // openmode.
+#include <boost/iostreams/positioning.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+
+namespace boost { namespace iostreams {
+
+//--------------Definitions of helper templates for device concepts-----------//
+
+template<typename Mode, typename Ch = char>
+struct device {
+    typedef Ch char_type;
+    struct category
+        : Mode,
+          device_tag,
+          closable_tag,
+          localizable_tag
+        { };
+
+    void close()
+    {
+        using namespace detail;
+        BOOST_STATIC_ASSERT((!is_convertible<Mode, two_sequence>::value));
+    }
+
+    void close(BOOST_IOS::openmode)
+    {
+        using namespace detail;
+        BOOST_STATIC_ASSERT((is_convertible<Mode, two_sequence>::value));
+    }
+
+    template<typename Locale>
+    void imbue(const Locale&) { }
+};
+
+template<typename Mode, typename Ch = wchar_t>
+struct wdevice : device<Mode, Ch> { };
+
+typedef device<input>    source;
+typedef wdevice<input>   wsource;
+typedef device<output>   sink;
+typedef wdevice<output>  wsink;
+
+//--------------Definitions of helper templates for simple filter concepts----//
+
+template<typename Mode, typename Ch = char>
+struct filter {
+    typedef Ch char_type;
+    struct category
+        : Mode,
+          filter_tag,
+          closable_tag,
+          localizable_tag
+        { };
+
+    template<typename Device>
+    void close(Device&)
+    {
+        using namespace detail;
+        BOOST_STATIC_ASSERT((!is_convertible<Mode, two_sequence>::value));
+        BOOST_STATIC_ASSERT((!is_convertible<Mode, dual_use>::value));
+    }
+
+    template<typename Device>
+    void close(Device&, BOOST_IOS::openmode)
+    {
+        using namespace detail;
+        BOOST_STATIC_ASSERT(
+            (is_convertible<Mode, two_sequence>::value) ||
+            (is_convertible<Mode, dual_use>::value)
+        );
+    }
+
+    template<typename Locale>
+    void imbue(const Locale&) { }
+};
+
+template<typename Mode, typename Ch = wchar_t>
+struct wfilter : filter<Mode, Ch> { };
+
+typedef filter<input>      input_filter;
+typedef wfilter<input>     input_wfilter;
+typedef filter<output>     output_filter;
+typedef wfilter<output>    output_wfilter;
+typedef filter<seekable>   seekable_filter;
+typedef wfilter<seekable>  seekable_wfilter;
+typedef filter<dual_use>   dual_use_filter;
+typedef wfilter<dual_use>  dual_use_wfilter;
+        
+//------Definitions of helper templates for multi-character filter cncepts----//
+
+template<typename Mode, typename Ch = char>
+struct multichar_filter : filter<Mode, Ch> {
+    struct category : filter<Mode, Ch>::category, multichar_tag { };
+};
+
+template<typename Mode, typename Ch = wchar_t>
+struct multichar_wfilter : multichar_filter<Mode, Ch> { };
+
+typedef multichar_filter<input>      multichar_input_filter;
+typedef multichar_wfilter<input>     multichar_input_wfilter;
+typedef multichar_filter<output>     multichar_output_filter;
+typedef multichar_wfilter<output>    multichar_output_wfilter;
+typedef multichar_filter<dual_use>   multichar_dual_use_filter;
+typedef multichar_wfilter<dual_use>  multichar_dual_use_wfilter;
+
+//----------------------------------------------------------------------------//
+
+} } // End namespaces iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_CONCEPTS_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/constants.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/constants.hpp
new file mode 100644
index 0000000000..55e6f5fdf3
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/constants.hpp
@@ -0,0 +1,42 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Contains constants used by library.
+
+#ifndef BOOST_IOSTREAMS_CONSTANTS_HPP_INCLUDED
+#define BOOST_IOSTREAMS_CONSTANTS_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#ifndef BOOST_IOSTREAMS_DEFAULT_DEVICE_BUFFER_SIZE
+# define BOOST_IOSTREAMS_DEFAULT_DEVICE_BUFFER_SIZE 4096
+#endif
+
+#ifndef BOOST_IOSTREAMS_DEFAULT_FILTER_BUFFER_SIZE
+# define BOOST_IOSTREAMS_DEFAULT_FILTER_BUFFER_SIZE 128
+#endif
+
+#ifndef BOOST_IOSTREAMS_DEFAULT_PBACK_BUFFER_SIZE
+# define BOOST_IOSTREAMS_DEFAULT_PBACK_BUFFER_SIZE 4
+#endif
+
+#include <boost/iostreams/detail/ios.hpp>  // streamsize.
+
+namespace boost { namespace iostreams {
+
+const std::streamsize default_device_buffer_size = 
+    BOOST_IOSTREAMS_DEFAULT_DEVICE_BUFFER_SIZE; 
+const std::streamsize default_filter_buffer_size = 
+    BOOST_IOSTREAMS_DEFAULT_FILTER_BUFFER_SIZE;
+const std::streamsize default_pback_buffer_size = 
+    BOOST_IOSTREAMS_DEFAULT_PBACK_BUFFER_SIZE;
+
+} } // End namespaces iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_CONSTANTS_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/access_control.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/access_control.hpp
new file mode 100644
index 0000000000..9c3328a226
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/access_control.hpp
@@ -0,0 +1,87 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Contains the definition of the class template access_control, which
+// allows the type of inheritance from a provided base class to be specified 
+// using a template parameter.
+
+
+#ifndef BOOST_IOSTREAMS_ACCESS_CONTROL_HPP_INCLUDED
+#define BOOST_IOSTREAMS_ACCESS_CONTROL_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <boost/iostreams/detail/select.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace iostreams {
+
+struct protected_ { };  // Represents protected inheritance.
+struct public_ { };     // Represents public inheritance.
+
+
+namespace detail {
+
+    // Implements protected inheritance.
+    template<typename U>
+    struct prot_ : protected U 
+    { 
+        prot_() { }
+        template<typename V> prot_(V v) : U(v) { }
+    };
+
+    // Implements public inheritance.
+    template<typename U> struct pub_ : public U { 
+        pub_() { }
+        template<typename V> pub_(V v) : U(v) { }
+    };
+
+//
+// Used to deduce the base type for the template access_control.
+//
+template<typename T, typename Access>
+struct access_control_base {
+    typedef int                                 bad_access_specifier;
+    typedef typename 
+            iostreams::select<  // Disambiguation for Tru64
+                ::boost::is_same<
+                    Access, protected_
+                >,                              prot_<T>,
+                ::boost::is_same<
+                    Access, public_
+                >,                              pub_<T>,
+                else_,                          bad_access_specifier
+            >::type                             type;
+};
+
+} // End namespace detail.
+
+//
+// Template name: access_control.
+// Description: Allows the type of inheritance from a provided base class
+//      to be specified using an int template parameter.
+// Template parameters:
+//      Base - The class from which to inherit (indirectly.)
+//      Access - The type of access desired. Must be one of the 
+//          values access_base::prot or access_base::pub.
+//
+template< typename T, typename Access,
+          typename Base = // VC6 workaraound (Compiler Error C2516)
+              typename detail::access_control_base<T, Access>::type >
+struct access_control : public Base { 
+    access_control() { }
+    template<typename U> explicit access_control(U u) : Base(u) { }
+};
+
+//----------------------------------------------------------------------------//
+
+} } // End namespaces iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_ACCESS_CONTROL_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/adapter/concept_adapter.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/adapter/concept_adapter.hpp
new file mode 100644
index 0000000000..5ca878b55a
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/adapter/concept_adapter.hpp
@@ -0,0 +1,289 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_CONCEPT_ADAPTER_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_CONCEPT_ADAPTER_HPP_INCLUDED
+
+#include <boost/config.hpp>                             // SFINAE.
+#include <boost/iostreams/concepts.hpp>
+#include <boost/iostreams/categories.hpp>
+#include <boost/iostreams/detail/adapter/non_blocking_adapter.hpp>
+#include <boost/iostreams/detail/call_traits.hpp>
+#include <boost/iostreams/detail/char_traits.hpp>
+#include <boost/iostreams/detail/dispatch.hpp>
+#include <boost/iostreams/detail/error.hpp>
+#include <boost/iostreams/detail/streambuf.hpp>        // pubsync.
+#include <boost/iostreams/detail/config/unreachable_return.hpp>
+#include <boost/iostreams/device/null.hpp>
+#include <boost/iostreams/traits.hpp>
+#include <boost/iostreams/operations.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/throw_exception.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>  // MSVC.
+
+
+namespace boost { namespace iostreams { namespace detail {
+
+template<typename Category> struct device_wrapper_impl;
+template<typename Category> struct flt_wrapper_impl;
+
+template<typename T>
+class concept_adapter {
+private:
+    typedef typename detail::value_type<T>::type       value_type;
+    typedef typename dispatch<T, input, output>::type  input_tag;
+    typedef typename dispatch<T, output, input>::type  output_tag;
+    typedef typename
+            mpl::if_<
+                is_device<T>,
+                device_wrapper_impl<input_tag>,
+                flt_wrapper_impl<input_tag>
+            >::type                                    input_impl;
+    typedef typename
+            mpl::if_<
+                is_device<T>,
+                device_wrapper_impl<output_tag>,
+                flt_wrapper_impl<output_tag>
+            >::type                                    output_impl;
+    typedef typename
+            mpl::if_<
+                is_device<T>,
+                device_wrapper_impl<any_tag>,
+                flt_wrapper_impl<any_tag>
+            >::type                                    any_impl;
+public:
+    typedef typename char_type_of<T>::type             char_type;
+    typedef typename category_of<T>::type              category;
+
+    explicit concept_adapter(const reference_wrapper<T>& ref) : t_(ref.get())
+    { BOOST_STATIC_ASSERT(is_std_io<T>::value); }
+    explicit concept_adapter(const T& t) : t_(t)
+    { BOOST_STATIC_ASSERT(!is_std_io<T>::value); }
+
+    concept_adapter(concept_adapter const& other) = default;
+
+    T& operator*() { return t_; }
+    T* operator->() { return &t_; }
+
+    std::streamsize read(char_type* s, std::streamsize n)
+    { return this->read(s, n, (basic_null_source<char_type>*) 0); }
+
+    template<typename Source>
+    std::streamsize read(char_type* s, std::streamsize n, Source* src)
+    { return input_impl::read(t_, src, s, n); }
+
+    std::streamsize write(const char_type* s, std::streamsize n)
+    { return this->write(s, n, (basic_null_sink<char_type>*) 0); }
+
+    template<typename Sink>
+    std::streamsize write(const char_type* s, std::streamsize n, Sink* snk)
+    { return output_impl::write(t_, snk, s, n); }
+
+    std::streampos seek( stream_offset off, BOOST_IOS::seekdir way,
+                         BOOST_IOS::openmode which )
+    { 
+        return this->seek( off, way, which, 
+                           (basic_null_device<char_type, seekable>*) 0); 
+    }
+
+    template<typename Device>
+    std::streampos seek( stream_offset off, BOOST_IOS::seekdir way,
+                         BOOST_IOS::openmode which, Device* dev )
+    { return any_impl::seek(t_, dev, off, way, which); }
+
+    void close(BOOST_IOS::openmode which)
+    { this->close(which, (basic_null_device<char_type, seekable>*) 0); }
+
+    template<typename Device>
+    void close(BOOST_IOS::openmode which, Device* dev)
+    { any_impl::close(t_, dev, which); }
+
+    template<typename Device>
+    bool flush( Device* dev )
+    {
+        bool result = any_impl::flush(t_, dev);
+        if (dev && dev->BOOST_IOSTREAMS_PUBSYNC() == -1)
+            result = false;
+        return result;
+    }
+
+    template<typename Locale> // Avoid dependency on <locale>
+    void imbue(const Locale& loc) { iostreams::imbue(t_, loc); }
+
+    std::streamsize optimal_buffer_size() const
+    { return iostreams::optimal_buffer_size(t_); }
+private:
+    BOOST_DELETED_FUNCTION(concept_adapter& operator=(const concept_adapter&));
+    value_type t_;
+};
+
+//------------------Specializations of device_wrapper_impl--------------------//
+
+template<>
+struct device_wrapper_impl<any_tag> {
+    template<typename Device, typename Dummy>
+    static std::streampos 
+    seek( Device& dev, Dummy*, stream_offset off, 
+          BOOST_IOS::seekdir way, BOOST_IOS::openmode which )
+    { 
+        typedef typename category_of<Device>::type category;
+        return seek(dev, off, way, which, category()); 
+    }
+
+    template<typename Device>
+    static std::streampos 
+    seek( Device&, stream_offset, BOOST_IOS::seekdir, 
+          BOOST_IOS::openmode, any_tag )
+    { 
+        boost::throw_exception(cant_seek());
+        BOOST_IOSTREAMS_UNREACHABLE_RETURN(0)
+    }
+
+    template<typename Device>
+    static std::streampos 
+    seek( Device& dev, stream_offset off, 
+          BOOST_IOS::seekdir way, BOOST_IOS::openmode which, 
+          random_access )
+    { 
+        return iostreams::seek(dev, off, way, which); 
+    }
+
+    template<typename Device, typename Dummy>
+    static void close(Device& dev, Dummy*, BOOST_IOS::openmode which)
+    { iostreams::close(dev, which); }
+
+    template<typename Device, typename Dummy>
+    static bool flush(Device& dev, Dummy*)
+    { return iostreams::flush(dev); }
+};
+
+
+template<>
+struct device_wrapper_impl<input> : device_wrapper_impl<any_tag>  {
+    template<typename Device, typename Dummy>
+    static std::streamsize
+    read( Device& dev, Dummy*, typename char_type_of<Device>::type* s,
+          std::streamsize n )
+    { return iostreams::read(dev, s, n); }
+
+    template<typename Device, typename Dummy>
+    static std::streamsize 
+    write( Device&, Dummy*, const typename char_type_of<Device>::type*,
+           std::streamsize )
+    { boost::throw_exception(cant_write());
+      BOOST_IOSTREAMS_UNREACHABLE_RETURN(0) }
+};
+
+template<>
+struct device_wrapper_impl<output> {
+    template<typename Device, typename Dummy>
+    static std::streamsize
+    read(Device&, Dummy*, typename char_type_of<Device>::type*, std::streamsize)
+    { boost::throw_exception(cant_read());
+      BOOST_IOSTREAMS_UNREACHABLE_RETURN(0) }
+
+    template<typename Device, typename Dummy>
+    static std::streamsize 
+    write( Device& dev, Dummy*, const typename char_type_of<Device>::type* s,
+           std::streamsize n )
+    { return iostreams::write(dev, s, n); }
+};
+
+//------------------Specializations of flt_wrapper_impl--------------------//
+
+template<>
+struct flt_wrapper_impl<any_tag> {
+    template<typename Filter, typename Device>
+    static std::streampos
+    seek( Filter& f, Device* dev, stream_offset off,
+          BOOST_IOS::seekdir way, BOOST_IOS::openmode which )
+    {
+        typedef typename category_of<Filter>::type category;
+        return seek(f, dev, off, way, which, category());
+    }
+
+    template<typename Filter, typename Device>
+    static std::streampos
+    seek( Filter&, Device*, stream_offset,
+          BOOST_IOS::seekdir, BOOST_IOS::openmode, any_tag )
+    { boost::throw_exception(cant_seek());
+      BOOST_IOSTREAMS_UNREACHABLE_RETURN(0) }
+
+    template<typename Filter, typename Device>
+    static std::streampos
+    seek( Filter& f, Device* dev, stream_offset off,
+          BOOST_IOS::seekdir way, BOOST_IOS::openmode which,
+          random_access tag )
+    {
+        typedef typename category_of<Filter>::type category;
+        return seek(f, dev, off, way, which, tag, category());
+    }
+
+    template<typename Filter, typename Device>
+    static std::streampos
+    seek( Filter& f, Device* dev, stream_offset off,
+          BOOST_IOS::seekdir way, BOOST_IOS::openmode,
+          random_access, any_tag )
+    { return f.seek(*dev, off, way); }
+
+    template<typename Filter, typename Device>
+    static std::streampos
+    seek( Filter& f, Device* dev, stream_offset off,
+          BOOST_IOS::seekdir way, BOOST_IOS::openmode which,
+          random_access, two_sequence )
+    { return f.seek(*dev, off, way, which);  }
+
+    template<typename Filter, typename Device>
+    static void close(Filter& f, Device* dev, BOOST_IOS::openmode which)
+    { iostreams::close(f, *dev, which); }
+
+    template<typename Filter, typename Device>
+    static bool flush(Filter& f, Device* dev)
+    { return iostreams::flush(f, *dev); }
+};
+
+template<>
+struct flt_wrapper_impl<input> {
+    template<typename Filter, typename Source>
+    static std::streamsize
+    read( Filter& f, Source* src, typename char_type_of<Filter>::type* s,
+          std::streamsize n )
+    { return iostreams::read(f, *src, s, n); }
+
+    template<typename Filter, typename Sink>
+    static std::streamsize 
+    write( Filter&, Sink*, const typename char_type_of<Filter>::type*, 
+           std::streamsize )
+    { boost::throw_exception(cant_write());
+      BOOST_IOSTREAMS_UNREACHABLE_RETURN(0) }
+};
+
+template<>
+struct flt_wrapper_impl<output> {
+    template<typename Filter, typename Source>
+    static std::streamsize
+    read(Filter&, Source*, typename char_type_of<Filter>::type*,std::streamsize)
+    { boost::throw_exception(cant_read());
+      BOOST_IOSTREAMS_UNREACHABLE_RETURN(0) }
+
+    template<typename Filter, typename Sink>
+    static std::streamsize 
+    write( Filter& f, Sink* snk, const typename char_type_of<Filter>::type* s,
+           std::streamsize n )
+    { return iostreams::write(f, *snk, s, n); }
+};
+
+//----------------------------------------------------------------------------//
+
+} } } // End namespaces detail, iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp>  // MSVC.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONCEPT_ADAPTER_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/adapter/mode_adapter.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/adapter/mode_adapter.hpp
new file mode 100644
index 0000000000..46e83c58af
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/adapter/mode_adapter.hpp
@@ -0,0 +1,117 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_MODE_ADAPTER_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_MODE_ADAPTER_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+// Contains the definition of the class template mode_adapter, which allows
+// a filter or device to function as if it has a different i/o mode than that
+// deduced by the metafunction mode_of.
+
+#include <boost/config.hpp>                // BOOST_MSVC.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/categories.hpp>
+#include <boost/iostreams/detail/ios.hpp>  // openmode, seekdir, int types. 
+#include <boost/iostreams/traits.hpp>
+#include <boost/iostreams/operations.hpp> 
+#include <boost/mpl/if.hpp> 
+
+namespace boost { namespace iostreams { namespace detail {
+
+template<typename Mode, typename T>
+class mode_adapter {
+private:
+    struct empty_base { };
+public:
+    typedef typename wrapped_type<T>::type  component_type;
+    typedef typename char_type_of<T>::type  char_type;
+    struct category 
+        : Mode, 
+          device_tag,
+          mpl::if_<is_filter<T>, filter_tag, device_tag>,
+          mpl::if_<is_filter<T>, multichar_tag, empty_base>,
+          closable_tag,
+          localizable_tag
+        { };
+    explicit mode_adapter(const component_type& t) : t_(t) { }
+
+        // Device member functions.
+
+    std::streamsize read(char_type* s, std::streamsize n);
+    std::streamsize write(const char_type* s, std::streamsize n);
+    std::streampos seek( stream_offset off, BOOST_IOS::seekdir way,
+                         BOOST_IOS::openmode which = 
+                             BOOST_IOS::in | BOOST_IOS::out );
+    void close();
+    void close(BOOST_IOS::openmode which);
+
+        // Filter member functions.
+
+    template<typename Source>
+    std::streamsize read(Source& src, char_type* s, std::streamsize n)
+    { return iostreams::read(t_, src, s, n); }
+
+    template<typename Sink>
+    std::streamsize write(Sink& snk, const char_type* s, std::streamsize n)
+    { return iostreams::write(t_, snk, s, n); }
+
+    template<typename Device>
+    std::streampos seek(Device& dev, stream_offset off, BOOST_IOS::seekdir way)
+    { return iostreams::seek(t_, dev, off, way); }
+
+    template<typename Device>
+    std::streampos seek( Device& dev, stream_offset off, 
+                         BOOST_IOS::seekdir way, BOOST_IOS::openmode which  )
+    { return iostreams::seek(t_, dev, off, way, which); }
+
+    template<typename Device>
+    void close(Device& dev)
+    { detail::close_all(t_, dev); }
+
+    template<typename Device>
+    void close(Device& dev, BOOST_IOS::openmode which)
+    { iostreams::close(t_, dev, which); }
+
+    template<typename Locale>
+    void imbue(const Locale& loc)
+    { iostreams::imbue(t_, loc); }
+private:
+    component_type t_;
+};
+                    
+//------------------Implementation of mode_adapter----------------------------//
+
+template<typename Mode, typename T>
+std::streamsize mode_adapter<Mode, T>::read
+    (char_type* s, std::streamsize n)
+{ return boost::iostreams::read(t_, s, n); }
+
+template<typename Mode, typename T>
+std::streamsize mode_adapter<Mode, T>::write
+    (const char_type* s, std::streamsize n)
+{ return boost::iostreams::write(t_, s, n); }
+
+template<typename Mode, typename T>
+std::streampos mode_adapter<Mode, T>::seek
+    (stream_offset off, BOOST_IOS::seekdir way, BOOST_IOS::openmode which)
+{ return boost::iostreams::seek(t_, off, way, which); }
+
+template<typename Mode, typename T>
+void mode_adapter<Mode, T>::close()
+{ detail::close_all(t_); }
+
+template<typename Mode, typename T>
+void mode_adapter<Mode, T>::close(BOOST_IOS::openmode which)
+{ iostreams::close(t_, which); }
+
+} } } // End namespaces detail, iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_MODE_ADAPTER_HPP_INCLUDED //-----//
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/adapter/non_blocking_adapter.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/adapter/non_blocking_adapter.hpp
new file mode 100644
index 0000000000..623cf769d2
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/adapter/non_blocking_adapter.hpp
@@ -0,0 +1,62 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2005-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_NON_BLOCKING_ADAPTER_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_NON_BLOCKING_ADAPTER_HPP_INCLUDED
+
+#include <boost/iostreams/detail/ios.hpp>  // streamsize, seekdir, openmode.
+#include <boost/iostreams/read.hpp>
+#include <boost/iostreams/seek.hpp>
+#include <boost/iostreams/traits.hpp>
+#include <boost/iostreams/write.hpp>
+
+namespace boost { namespace iostreams {
+
+template<typename Device>
+class non_blocking_adapter {
+public:
+    typedef typename char_type_of<Device>::type char_type;
+    struct category
+        : mode_of<Device>::type, device_tag
+        { };
+    explicit non_blocking_adapter(Device& dev) : device_(dev) { }
+    std::streamsize read(char_type* s, std::streamsize n)
+    { 
+        std::streamsize result = 0;
+        while (result < n) {
+            std::streamsize amt = iostreams::read(device_, s, n);
+            if (amt == -1)
+                break;
+            result += amt;
+        }
+        return result != 0 ? result : -1;
+    }
+    std::streamsize write(const char_type* s, std::streamsize n)
+    { 
+        std::streamsize result = 0;
+        while (result < n) {
+            std::streamsize amt = 
+                iostreams::write(device_, s + result, n - result);
+            // write errors, like EOF on read, need to be handled.
+            if (amt == -1)
+                break;
+            result += amt;
+        }
+        return result;    
+    }
+    std::streampos seek( stream_offset off, BOOST_IOS::seekdir way,
+                         BOOST_IOS::openmode which = 
+                             BOOST_IOS::in | BOOST_IOS::out )
+    { return iostreams::seek(device_, off, way, which); }
+public:
+    non_blocking_adapter& operator=(const non_blocking_adapter&);
+    Device& device_;
+};
+
+} } // End namespace iostreams.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_NON_BLOCKING_ADAPTER_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/adapter/output_iterator_adapter.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/adapter/output_iterator_adapter.hpp
new file mode 100644
index 0000000000..2ed9039c7b
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/adapter/output_iterator_adapter.hpp
@@ -0,0 +1,41 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_OUTPUT_ITERATOR_ADAPTER_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_OUTPUT_ITERATOR_ADAPTER_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <algorithm>                      // copy.
+#include <iosfwd>                         // streamsize.
+#include <boost/iostreams/categories.hpp> // tags.
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+
+namespace boost { namespace iostreams { namespace detail {
+
+template<typename Mode, typename Ch, typename OutIt>
+class output_iterator_adapter {
+public:
+    BOOST_STATIC_ASSERT((is_convertible<Mode, output>::value));
+    typedef Ch        char_type;
+    typedef sink_tag  category;
+    explicit output_iterator_adapter(OutIt out) : out_(out) { }
+    std::streamsize write(const char_type* s, std::streamsize n) 
+    { 
+        std::copy(s, s + n, out_); 
+        return n; 
+    }
+private:
+    OutIt out_;
+};
+
+} } } // End namespaces detail, iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_OUTPUT_ITERATOR_ADAPTER_HPP_INCLUDED //-----//
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/adapter/range_adapter.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/adapter/range_adapter.hpp
new file mode 100644
index 0000000000..b7fe56f7ed
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/adapter/range_adapter.hpp
@@ -0,0 +1,187 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_RANGE_ADAPTER_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_RANGE_ADAPTER_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <algorithm>                             // min.
+#include <boost/assert.hpp>
+#include <cstddef>                               // ptrdiff_t.
+#include <iosfwd>                                // streamsize, streamoff.
+#include <boost/detail/iterator.hpp>             // boost::iterator_traits.
+#include <boost/iostreams/categories.hpp>
+#include <boost/iostreams/detail/error.hpp>
+#include <boost/iostreams/positioning.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/utility/enable_if.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>  // MSVC.
+
+namespace boost { namespace iostreams { namespace detail {
+
+// Used for simulated tag dispatch.
+template<typename Traversal> struct range_adapter_impl;
+
+//
+// Template name: range_adapter
+// Description: Device based on an instance of boost::iterator_range.
+// Template parameters:
+//     Mode - A mode tag.
+//     Range - An instance of iterator_range.
+//
+template<typename Mode, typename Range>
+class range_adapter {
+private:
+    typedef typename Range::iterator                  iterator;
+    typedef boost::detail::iterator_traits<iterator>  iter_traits;
+    typedef typename iter_traits::iterator_category   iter_cat;
+public:
+    typedef typename Range::value_type                char_type;
+    struct category : Mode, device_tag { };
+    typedef typename
+            mpl::if_<
+                is_convertible<
+                    iter_cat,
+                    std::random_access_iterator_tag
+                >,
+                std::random_access_iterator_tag,
+                std::forward_iterator_tag
+            >::type                                   tag;
+    typedef range_adapter_impl<tag>                   impl;
+
+    explicit range_adapter(const Range& rng);
+    range_adapter(iterator first, iterator last);
+    std::streamsize read(char_type* s, std::streamsize n);
+    std::streamsize write(const char_type* s, std::streamsize n);
+    std::streampos seek(stream_offset off, BOOST_IOS::seekdir way);
+private:
+    iterator first_, cur_, last_;
+};
+
+//------------------Implementation of range_adapter---------------------------//
+
+template<typename Mode, typename Range>
+range_adapter<Mode, Range>::range_adapter(const Range& rng)
+    : first_(rng.begin()), cur_(rng.begin()), last_(rng.end()) { }
+
+template<typename Mode, typename Range>
+range_adapter<Mode, Range>::range_adapter(iterator first, iterator last)
+    : first_(first), cur_(first), last_(last) { }
+
+template<typename Mode, typename Range>
+inline std::streamsize range_adapter<Mode, Range>::read
+    (char_type* s, std::streamsize n)
+{ return impl::read(cur_, last_, s, n); }
+
+template<typename Mode, typename Range>
+inline std::streamsize range_adapter<Mode, Range>::write
+    (const char_type* s, std::streamsize n)
+{ return impl::write(cur_, last_, s, n); }
+
+
+template<typename Mode, typename Range>
+std::streampos range_adapter<Mode, Range>::seek
+    (stream_offset off, BOOST_IOS::seekdir way)
+{ 
+    impl::seek(first_, cur_, last_, off, way); 
+    return offset_to_position(cur_ - first_);
+}
+
+//------------------Implementation of range_adapter_impl----------------------//
+
+template<>
+struct range_adapter_impl<std::forward_iterator_tag> {
+    template<typename Iter, typename Ch>
+    static std::streamsize read
+        (Iter& cur, Iter& last, Ch* s,std::streamsize n)
+    {
+        std::streamsize rem = n; // No. of chars remaining.
+        while (cur != last && rem-- > 0) *s++ = *cur++;
+        return n - rem != 0 ? n - rem : -1;
+    }
+
+    template<typename Iter, typename Ch>
+    static std::streamsize write
+        (Iter& cur, Iter& last, const Ch* s, std::streamsize n)
+    {
+        while (cur != last && n-- > 0) *cur++ = *s++;
+        if (cur == last && n > 0)
+            boost::throw_exception(write_area_exhausted());
+        return n;
+    }
+};
+
+template<>
+struct range_adapter_impl<std::random_access_iterator_tag> {
+    template<typename Iter, typename Ch>
+    static std::streamsize read
+        (Iter& cur, Iter& last, Ch* s,std::streamsize n)
+    {
+        std::streamsize result = 
+            (std::min)(static_cast<std::streamsize>(last - cur), n);
+        if (result)
+            std::copy(cur, cur + result, s);
+        cur += result;
+        return result != 0 ? result : -1;
+    }
+
+    template<typename Iter, typename Ch>
+    static std::streamsize write
+        (Iter& cur, Iter& last, const Ch* s, std::streamsize n)
+    {
+        std::streamsize count =
+            (std::min)(static_cast<std::streamsize>(last - cur), n);
+        std::copy(s, s + count, cur);
+        cur += count;
+        if (count < n) 
+            boost::throw_exception(write_area_exhausted());
+        return n;
+    }
+
+    template<typename Iter>
+    static void seek
+        ( Iter& first, Iter& cur, Iter& last, stream_offset off,
+          BOOST_IOS::seekdir way )
+    {
+        using namespace std;
+        switch (way) {
+        case BOOST_IOS::beg:
+            if (off > last - first || off < 0)
+                boost::throw_exception(bad_seek());
+            cur = first + off;
+            break;
+        case BOOST_IOS::cur:
+            {
+                std::ptrdiff_t newoff = cur - first + off;
+                if (newoff > last - first || newoff < 0)
+                    boost::throw_exception(bad_seek());
+                cur += off;
+                break;
+            }
+        case BOOST_IOS::end:
+            if (last - first + off < 0 || off > 0)
+                boost::throw_exception(bad_seek());
+            cur = last + off;
+            break;
+        default:
+            BOOST_ASSERT(0);
+        }
+    }
+};
+
+} } } // End namespaces detail, iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp>  // MSVC.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_RANGE_ADAPTER_HPP_INCLUDED //---------------//
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/bool_trait_def.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/bool_trait_def.hpp
new file mode 100644
index 0000000000..c3fb9d587b
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/bool_trait_def.hpp
@@ -0,0 +1,49 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_BOOL_TRAIT_DEF_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_BOOL_TRAIT_DEF_HPP_INCLUDED     
+
+#include <boost/config.hpp> // BOOST_STATIC_CONSTANT.
+#include <boost/iostreams/detail/template_params.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/type_traits/detail/yes_no_type.hpp>
+ 
+// 
+// Macro name: BOOST_IOSTREAMS_BOOL_TRAIT_DEF
+// Description: Used to generate the traits classes is_istream, is_ostream,
+//      etc.
+//
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
+# define BOOST_IOSTREAMS_TRAIT_NAMESPACE(trait)
+#else
+# define BOOST_IOSTREAMS_TRAIT_NAMESPACE(trait) BOOST_PP_CAT(trait, _impl_):: 
+#endif
+#define BOOST_IOSTREAMS_BOOL_TRAIT_DEF(trait, type, arity) \
+    namespace BOOST_PP_CAT(trait, _impl_) { \
+      BOOST_IOSTREAMS_TEMPLATE_PARAMS(arity, T) \
+      type_traits::yes_type helper \
+          (const volatile type BOOST_IOSTREAMS_TEMPLATE_ARGS(arity, T)*); \
+      type_traits::no_type helper(...); \
+      template<typename T> \
+      struct impl { \
+           BOOST_STATIC_CONSTANT(bool, value = \
+           (sizeof(BOOST_IOSTREAMS_TRAIT_NAMESPACE(trait) \
+              helper(static_cast<T*>(0))) == \
+                sizeof(type_traits::yes_type))); \
+      }; \
+    } \
+    template<typename T> \
+    struct trait \
+        : mpl::bool_<BOOST_PP_CAT(trait, _impl_)::impl<T>::value> \
+    { BOOST_MPL_AUX_LAMBDA_SUPPORT(1, trait, (T)) }; \
+    /**/
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_BOOL_TRAIT_DEF_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/broken_overload_resolution/forward.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/broken_overload_resolution/forward.hpp
new file mode 100644
index 0000000000..4444916c3a
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/broken_overload_resolution/forward.hpp
@@ -0,0 +1,31 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_BROKEN_OVERLOAD_RESOLUTION_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_BROKEN_OVERLOAD_RESOLUTION_HPP_INCLUDED
+
+#include <boost/config.hpp>                     // BOOST_STATIC_CONSANT.
+#include <boost/mpl/bool.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace iostreams { namespace detail {
+
+template<typename Device, typename U>
+struct forward_impl {
+    BOOST_STATIC_CONSTANT(bool, value =
+        ( !is_same< U, Device >::value &&
+          !is_same< U, reference_wrapper<Device> >::value ));
+};
+
+template<typename Device, typename U>
+struct forward
+    : mpl::bool_<forward_impl<Device, U>::value>
+    { };
+
+} } } // End namespaces detail, iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_BROKEN_OVERLOAD_RESOLUTION_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/broken_overload_resolution/stream_buffer.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/broken_overload_resolution/stream_buffer.hpp
new file mode 100644
index 0000000000..d5c7107087
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/broken_overload_resolution/stream_buffer.hpp
@@ -0,0 +1,189 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_BROKEN_OVERLOAD_RESOLUTION_STREAM_BUFFER_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_BROKEN_OVERLOAD_RESOLUTION_STREAM_BUFFER_HPP_INCLUDED
+
+#include <boost/iostreams/detail/broken_overload_resolution/forward.hpp>
+#include <boost/throw_exception.hpp>
+
+namespace boost { namespace iostreams {
+
+template< typename T, 
+          typename Tr = 
+              BOOST_IOSTREAMS_CHAR_TRAITS(
+                  BOOST_DEDUCED_TYPENAME char_type_of<T>::type 
+              ),
+          typename Alloc = 
+              std::allocator<
+                  BOOST_DEDUCED_TYPENAME char_type_of<T>::type 
+              >,
+          typename Mode = BOOST_DEDUCED_TYPENAME mode_of<T>::type >
+class stream_buffer
+    : public detail::stream_buffer_traits<T, Tr, Alloc, Mode>::type
+{
+private:
+    BOOST_STATIC_ASSERT((
+        is_convertible<
+            BOOST_DEDUCED_TYPENAME iostreams::category_of<T>::type, Mode
+        >::value
+    ));
+    typedef typename 
+            detail::stream_buffer_traits<
+                T, Tr, Alloc, Mode
+            >::type                           base_type;
+public:
+    typedef typename char_type_of<T>::type    char_type;
+    struct category 
+        : Mode,
+          closable_tag,
+          streambuf_tag
+        { };
+    BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr)
+    stream_buffer() { }
+    ~stream_buffer()
+    { 
+        try { 
+            if (this->is_open() && this->auto_close()) 
+                this->close(); 
+        } catch (...) { } 
+    }
+    template<typename U0>
+    stream_buffer(const U0& u0)
+    {
+        open_impl(detail::forward<T, U0>(), u0);
+    }
+    template<typename U0, typename U1>
+    stream_buffer(const U0& u0, const U1& u1)
+    {
+        open_impl(detail::forward<T, U0>(), u0, u1);
+    }
+    template<typename U0, typename U1, typename U2>
+    stream_buffer(const U0& u0, const U1& u1, const U2& u2)
+    {
+        open_impl(detail::forward<T, U0>(), u0, u1, u2);
+    }
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
+    template<typename U0>
+    stream_buffer(U0& u0)
+    {
+        open_impl(detail::forward<T, U0>(), u0);
+    }
+    template<typename U0, typename U1>
+    stream_buffer(U0& u0, const U1& u1)
+    {
+        open_impl(detail::forward<T, U0>(), u0, u1);
+    }
+    template<typename U0, typename U1, typename U2>
+    stream_buffer(U0& u0, const U1& u1, const U2& u2)
+    {
+        open_impl(detail::forward<T, U0>(), u0, u1, u2);
+    }
+#endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------//
+    template<typename U0>
+    void open(const U0& u0)
+    {
+        open_impl(detail::forward<T, U0>(), u0);
+    }
+    template<typename U0, typename U1>
+    void open(const U0& u0, const U1& u1)
+    {
+        open_impl(detail::forward<T, U0>(), u0, u1);
+    }
+    template<typename U0, typename U1, typename U2>
+    void open(const U0& u0, const U1& u1, const U2& u2)
+    {
+        open_impl(detail::forward<T, U0>(), u0, u1, u2);
+    }
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
+    template<typename U0>
+    void open(U0& u0)
+    {
+        open_impl(detail::forward<T, U0>(), u0);
+    }
+    template<typename U0, typename U1>
+    void open(U0& u0, const U1& u1)
+    {
+        open_impl(detail::forward<T, U0>(), u0, u1);
+    }
+    template<typename U0, typename U1, typename U2>
+    void open(U0& u0, const U1& u1, const U2& u2)
+    {
+        open_impl(detail::forward<T, U0>(), u0, u1, u2);
+    }
+#endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------//
+    T& operator*() { return *this->component(); }
+    T* operator->() { return this->component(); }
+private:
+    template<typename U0>
+    void open_impl(mpl::false_, const U0& u0)
+    {
+        base_type::open(const_cast<U0&>(u0), -1, -1);
+    }
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
+    template<typename U0>
+    void open_impl(mpl::false_, U0& u0)
+    {
+        base_type::open(detail::wrap(u0), -1, -1);
+    }
+#endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------//
+    template<typename U0>
+    void open_impl(mpl::true_, const U0& u0)
+    {
+        base_type::open(T(const_cast<U0&>(u0)), -1, -1);
+    }
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
+    template<typename U0>
+    void open_impl(mpl::true_, U0& u0)
+    {
+        base_type::open(T(u0), -1, -1);
+    }
+#endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------//
+    template<typename U0, typename U1>
+    void open_impl(mpl::false_, const U0& u0, const U1& u1)
+    {
+        base_type::open(u0, u1, -1);
+    }
+    template<typename U0, typename U1>
+    void open_impl(mpl::true_, const U0& u0, const U1& u1)
+    {
+        base_type::open(T(const_cast<U0&>(u0), u1), -1, -1);
+    }
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
+    template<typename U0, typename U1>
+    void open_impl(mpl::true_, U0& u0, const U1& u1)
+    {
+        base_type::open(T(u0, u1), -1, -1);
+    }
+#endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------//
+    template<typename U0, typename U1, typename U2>
+    void open_impl(mpl::false_, const U0& u0, const U1& u1, const U2& u2)
+    {
+        base_type::open(u0, u1, u2);
+    }
+    template<typename U0, typename U1, typename U2>
+    void open_impl(mpl::true_, const U0& u0, const U1& u1, const U2& u2)
+    {
+        base_type::open(T(const_cast<U0&>(u0), u1, u2), -1, -1);
+    }
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
+    template<typename U0, typename U1, typename U2>
+    void open_impl(mpl::true_, U0& u0, const U1& u1, const U2& u2)
+    {
+        base_type::open(T(u0, u1, u2), -1, -1);
+    }
+#endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------//
+    void check_open()
+    {
+        if (this->is_open()) 
+            boost::throw_exception(BOOST_IOSTREAMS_FAILURE("already open"));
+    }
+};
+
+} } // End namespaces iostreams, boost.
+
+#endif // BOOST_IOSTREAMS_DETAIL_BROKEN_OVERLOAD_RESOLUTION_STREAM_BUFFER_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/buffer.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/buffer.hpp
new file mode 100644
index 0000000000..35cb33c700
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/buffer.hpp
@@ -0,0 +1,229 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_BUFFERS_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_BUFFERS_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <algorithm>                           // swap.
+#include <memory>                              // allocator.
+#include <boost/config.hpp>                    // member templates.
+#include <boost/iostreams/char_traits.hpp>
+#include <boost/iostreams/detail/ios.hpp>      // streamsize.
+#include <boost/iostreams/read.hpp>
+#include <boost/iostreams/traits.hpp>          // int_type_of.
+#include <boost/iostreams/checked_operations.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace iostreams { namespace detail {
+
+//----------------Buffers-----------------------------------------------------//
+
+//
+// Template name: buffer
+// Description: Character buffer.
+// Template parameters:
+//     Ch - The character type.
+//     Alloc - The Allocator type.
+//
+template< typename Ch,
+          typename Alloc = std::allocator<Ch> >
+class basic_buffer {
+private:
+#ifndef BOOST_NO_STD_ALLOCATOR
+#if defined(BOOST_NO_CXX11_ALLOCATOR)
+    typedef typename Alloc::template rebind<Ch>::other allocator_type;
+#else
+    typedef typename std::allocator_traits<Alloc>::template rebind_alloc<Ch> allocator_type;
+    typedef std::allocator_traits<allocator_type> allocator_traits;
+#endif
+#else
+    typedef std::allocator<Ch> allocator_type;
+#endif
+    static Ch* allocate(std::streamsize buffer_size);
+public:
+    basic_buffer();
+    basic_buffer(std::streamsize buffer_size);
+    ~basic_buffer();
+    void resize(std::streamsize buffer_size);
+    Ch* begin() const { return buf_; }
+    Ch* end() const { return buf_ + size_; }
+    Ch* data() const { return buf_; }
+    std::streamsize size() const { return size_; }
+    void swap(basic_buffer& rhs);
+private:
+    // Disallow copying and assignment.
+    basic_buffer(const basic_buffer&);
+    basic_buffer& operator=(const basic_buffer&);
+    Ch*              buf_;
+    std::streamsize  size_;
+};
+
+template<typename Ch, typename Alloc>
+void swap(basic_buffer<Ch, Alloc>& lhs, basic_buffer<Ch, Alloc>& rhs)
+{ lhs.swap(rhs); }
+
+//
+// Template name: buffer
+// Description: Character buffer with two pointers accessible via ptr() and
+//      eptr().
+// Template parameters:
+//     Ch - A character type.
+//
+template< typename Ch,
+          typename Alloc = std::allocator<Ch> >
+class buffer : public basic_buffer<Ch, Alloc> {
+private:
+    typedef basic_buffer<Ch, Alloc> base;
+public:
+    typedef iostreams::char_traits<Ch> traits_type;
+    using base::resize; 
+    using base::data; 
+    using base::size;
+    typedef Ch* const const_pointer;
+    buffer(std::streamsize buffer_size);
+    Ch* & ptr() { return ptr_; }
+    const_pointer& ptr() const { return ptr_; }
+    Ch* & eptr() { return eptr_; }
+    const_pointer& eptr() const { return eptr_; }
+    void set(std::streamsize ptr, std::streamsize end);
+    void swap(buffer& rhs);
+
+    // Returns an int_type as a status code.
+    template<typename Source>
+    typename int_type_of<Source>::type fill(Source& src) 
+    {
+        using namespace std;
+        std::streamsize keep;
+        if ((keep = static_cast<std::streamsize>(eptr_ - ptr_)) > 0)
+            traits_type::move(
+                this->data(),
+                ptr_, 
+                static_cast<size_t>(keep)
+            );
+        set(0, keep);
+        std::streamsize result = 
+            iostreams::read(src, this->data() + keep, this->size() - keep);
+        if (result != -1)
+            this->set(0, keep + result);
+        return result == -1 ?
+            traits_type::eof() :
+                result == 0 ?
+                    traits_type::would_block() :
+                    traits_type::good();
+
+    }
+
+    // Returns true if one or more characters were written.
+    template<typename Sink>
+    bool flush(Sink& dest) 
+    {
+        using namespace std;
+        std::streamsize amt = static_cast<std::streamsize>(eptr_ - ptr_);
+        std::streamsize result = iostreams::write_if(dest, ptr_, amt);
+        if (result < amt) {
+            traits_type::move( this->data(), 
+                               ptr_ + static_cast<size_t>(result), 
+                               static_cast<size_t>(amt - result) );
+        }
+        this->set(0, amt - result);
+        return result != 0;
+    }
+private:
+    Ch *ptr_, *eptr_;
+};
+
+template<typename Ch, typename Alloc>
+void swap(buffer<Ch, Alloc>& lhs, buffer<Ch, Alloc>& rhs)
+{ lhs.swap(rhs); }
+
+//--------------Implementation of basic_buffer--------------------------------//
+
+template<typename Ch, typename Alloc>
+basic_buffer<Ch, Alloc>::basic_buffer() : buf_(0), size_(0) { }
+
+template<typename Ch, typename Alloc>
+inline Ch* basic_buffer<Ch, Alloc>::allocate(std::streamsize buffer_size)
+{
+#if defined(BOOST_NO_CXX11_ALLOCATOR) || defined(BOOST_NO_STD_ALLOCATOR)
+    return static_cast<Ch*>(allocator_type().allocate(
+           static_cast<BOOST_DEDUCED_TYPENAME Alloc::size_type>(buffer_size), 0));
+#else
+    allocator_type alloc;
+    return static_cast<Ch*>(allocator_traits::allocate(alloc,
+           static_cast<BOOST_DEDUCED_TYPENAME allocator_traits::size_type>(buffer_size)));
+#endif
+}
+
+template<typename Ch, typename Alloc>
+basic_buffer<Ch, Alloc>::basic_buffer(std::streamsize buffer_size)
+    : buf_(allocate(buffer_size)),
+      size_(buffer_size) // Cast for SunPro 5.3.
+    { }
+
+template<typename Ch, typename Alloc>
+inline basic_buffer<Ch, Alloc>::~basic_buffer()
+{
+    if (buf_) {
+#if defined(BOOST_NO_CXX11_ALLOCATOR) || defined(BOOST_NO_STD_ALLOCATOR)
+        allocator_type().deallocate(buf_,
+            static_cast<BOOST_DEDUCED_TYPENAME Alloc::size_type>(size_));
+#else
+        allocator_type alloc;
+        allocator_traits::deallocate(alloc, buf_,
+            static_cast<BOOST_DEDUCED_TYPENAME allocator_traits::size_type>(size_));
+#endif
+    }
+}
+
+template<typename Ch, typename Alloc>
+inline void basic_buffer<Ch, Alloc>::resize(std::streamsize buffer_size)
+{
+    if (size_ != buffer_size) {
+        basic_buffer<Ch, Alloc> temp(buffer_size);
+        std::swap(size_, temp.size_);
+        std::swap(buf_, temp.buf_);
+    }
+}
+
+template<typename Ch, typename Alloc>
+void basic_buffer<Ch, Alloc>::swap(basic_buffer& rhs) 
+{ 
+    std::swap(buf_, rhs.buf_); 
+    std::swap(size_, rhs.size_); 
+}
+
+//--------------Implementation of buffer--------------------------------------//
+
+template<typename Ch, typename Alloc>
+buffer<Ch, Alloc>::buffer(std::streamsize buffer_size)
+    : basic_buffer<Ch, Alloc>(buffer_size) { }
+
+template<typename Ch, typename Alloc>
+inline void buffer<Ch, Alloc>::set(std::streamsize ptr, std::streamsize end)
+{ 
+    ptr_ = data() + ptr; 
+    eptr_ = data() + end; 
+}
+
+template<typename Ch, typename Alloc>
+inline void buffer<Ch, Alloc>::swap(buffer& rhs) 
+{ 
+    base::swap(rhs); 
+    std::swap(ptr_, rhs.ptr_); 
+    std::swap(eptr_, rhs.eptr_); 
+}
+
+//----------------------------------------------------------------------------//
+
+} } } // End namespaces detail, iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_BUFFERS_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/call_traits.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/call_traits.hpp
new file mode 100644
index 0000000000..be6123737b
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/call_traits.hpp
@@ -0,0 +1,32 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_VALUE_TYPE_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_VALUE_TYPE_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <boost/iostreams/traits.hpp>
+#include <boost/mpl/if.hpp>
+
+namespace boost { namespace iostreams { namespace detail {
+
+template<typename T>
+struct param_type {
+    typedef typename mpl::if_<is_std_io<T>, T&, const T&>::type type;
+};
+
+template<typename T>
+struct value_type {
+    typedef typename mpl::if_<is_std_io<T>, T&, T>::type type;
+};
+
+} } } // End namespaces detail, iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_VALUE_TYPE_HPP_INCLUDED //-----------//
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/char_traits.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/char_traits.hpp
new file mode 100644
index 0000000000..ce3eb6dbe7
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/char_traits.hpp
@@ -0,0 +1,63 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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.)
+
+// Provides std::char_traits for libraries without templated streams. Should not
+// be confused with <boost/iostreams/char_traits.hpp>, which defines the
+// template boost::iostreams::char_traits.
+
+// See http://www.boost.org/libs/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_CHAR_TRAITS_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_CHAR_TRAITS_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <iosfwd>
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#ifdef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
+# include <boost/config.hpp> // Make sure size_t is in std.
+# include <cstddef>
+# include <cstring>
+# include <cstdio>
+#endif
+
+#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //--------------------------------//
+# define BOOST_IOSTREAMS_CHAR_TRAITS(ch) std::char_traits< ch >
+#else
+# define BOOST_IOSTREAMS_CHAR_TRAITS(ch) boost::iostreams::detail::char_traits
+
+namespace boost { namespace iostreams { namespace detail {
+
+struct char_traits  {
+    typedef char            char_type;
+    typedef int             int_type;
+    typedef std::streampos  pos_type;
+    typedef std::streamoff  off_type;
+
+    // Note: this may not be not conforming, since it treats chars as unsigned,
+    // but is only used to test for equality.
+    static int compare(const char* lhs, const char* rhs, std::size_t n)
+    { return std::strncmp(lhs, rhs, n); }
+    static char* copy(char *dest, const char *src, std::size_t n)
+    { return static_cast<char*>(std::memcpy(dest, src, n)); }
+    static char* move(char *dest, const char *src, std::size_t n)
+    { return static_cast<char*>(std::memmove(dest, src, n)); }
+    static const char* find(const char* s, std::size_t n, const char& c)
+    { return (const char*) (const void*) std::memchr(s, c, n); }
+    static char to_char_type(const int& c) { return c; }
+    static int to_int_type(const char& c) { return c; }
+    static bool eq_int_type(const int& lhs, const int& rhs)
+    { return lhs == rhs; }
+    static int eof() { return EOF; }
+    static int not_eof(const int& c) { return c != EOF ? c : '\n'; }
+};
+
+} } } // End namespaces detail, iostreams, boost.
+
+#endif // #ifdef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //-----------------------//
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CHAR_TRAITS_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/auto_link.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/auto_link.hpp
new file mode 100644
index 0000000000..07ab23c3c1
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/auto_link.hpp
@@ -0,0 +1,49 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Adapted from <boost/config/auto_link.hpp> and from
+// http://www.boost.org/more/separate_compilation.html, by John Maddock.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_AUTO_LINK_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_AUTO_LINK_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#if defined(BOOST_EXTERNAL_LIB_NAME)
+# if defined(BOOST_MSVC) \
+     || defined(__BORLANDC__) \
+     || (defined(__MWERKS__) && defined(_WIN32) && (__MWERKS__ >= 0x3000)) \
+     || (defined(__ICL) && defined(_MSC_EXTENSIONS)) \
+     /**/
+#  pragma comment(lib, BOOST_EXTERNAL_LIB_NAME)
+# endif
+# undef BOOST_EXTERNAL_LIB_NAME
+#endif
+
+//------------------Enable automatic library variant selection----------------// 
+
+#if !defined(BOOST_IOSTREAMS_SOURCE) && \
+    !defined(BOOST_ALL_NO_LIB) && \
+    !defined(BOOST_IOSTREAMS_NO_LIB) \
+    /**/
+
+// 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_iostreams
+
+// If we're importing code from a dll, then tell auto_link.hpp about it.
+# if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_IOSTREAMS_DYN_LINK)
+#  define BOOST_DYN_LINK
+# endif
+
+// And include the header that does the work.
+# include <boost/config/auto_link.hpp>
+#endif  // auto-linking disabled
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_AUTO_LINK_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/bzip2.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/bzip2.hpp
new file mode 100644
index 0000000000..bfcda40560
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/bzip2.hpp
@@ -0,0 +1,48 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Adapted from <boost/config/auto_link.hpp> and from
+// http://www.boost.org/more/separate_compilation.html, by John Maddock.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_BZIP2_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_CONFIG_BZIP2_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#if defined(BOOST_BZIP2_BINARY)
+# if defined(BOOST_MSVC) || \
+     defined(__BORLANDC__) || \
+     (defined(__MWERKS__) && defined(_WIN32) && (__MWERKS__ >= 0x3000)) || \
+     (defined(__ICL) && defined(_MSC_EXTENSIONS)) \
+     /**/
+
+// Specify the name of the .lib file.
+#  pragma comment(lib, BOOST_STRINGIZE(BOOST_BZIP2_BINARY))
+# endif
+#else 
+# if !defined(BOOST_IOSTREAMS_SOURCE) && \
+     !defined(BOOST_ALL_NO_LIB) && \
+     !defined(BOOST_IOSTREAMS_NO_LIB) \
+     /**/
+
+// 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_bzip2
+
+// If we're importing code from a dll, then tell auto_link.hpp about it.
+#  if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_IOSTREAMS_DYN_LINK)
+#   define BOOST_DYN_LINK
+#  endif
+
+// And include the header that does the work.
+#  include <boost/config/auto_link.hpp>
+# endif
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_BZIP2_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/codecvt.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/codecvt.hpp
new file mode 100644
index 0000000000..6519ddcd44
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/codecvt.hpp
@@ -0,0 +1,81 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_CODECVT_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_CONFIG_CODECVT_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#include <cstddef>
+
+#if defined(_MSC_VER)
+# pragma once
+#endif       
+
+//------------------Support for codecvt with user-defined state types---------//
+
+#if defined(__MSL_CPP__) || defined(__LIBCOMO__) || \
+    BOOST_WORKAROUND(_STLPORT_VERSION, <= 0x450) || \
+    defined(_LIBCPP_VERSION) \
+    /**/
+# define BOOST_IOSTREAMS_NO_PRIMARY_CODECVT_DEFINITION
+#endif
+
+#if defined(__GLIBCPP__) || defined(__GLIBCXX__) || \
+    BOOST_WORKAROUND(_STLPORT_VERSION, > 0x450) \
+    /**/
+# define BOOST_IOSTREAMS_EMPTY_PRIMARY_CODECVT_DEFINITION
+#endif
+
+//------------------Check for codecvt ctor taking a reference count-----------//
+
+#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205)) || \
+    BOOST_WORKAROUND(_STLPORT_VERSION, < 0x461) \
+    /**/
+# define BOOST_IOSTREAMS_NO_CODECVT_CTOR_FROM_SIZE_T
+#endif
+
+//------------------Normalize codecvt::length---------------------------------//
+
+#if !defined(__MSL_CPP__) && !defined(__LIBCOMO__) && \
+    (!defined(BOOST_RWSTD_VER) || BOOST_RWSTD_VER < 0x04010300) && \
+    (!defined(__MACH__) || !defined(__INTEL_COMPILER))
+    /**/
+# define BOOST_IOSTREAMS_CODECVT_CV_QUALIFIER const
+#else
+# define BOOST_IOSTREAMS_CODECVT_CV_QUALIFIER
+#endif
+
+//------------------Check for codecvt::max_length-----------------------------//
+
+#if BOOST_WORKAROUND(_STLPORT_VERSION, < 0x461)
+# define BOOST_IOSTREAMS_NO_CODECVT_MAX_LENGTH
+#endif
+                    
+//------------------Put mbstate_t and codecvt in std--------------------------//
+
+#ifndef BOOST_IOSTREAMS_NO_LOCALE
+# include <locale>
+#endif
+
+// From Robert Ramey's version of utf8_codecvt_facet.
+namespace std { 
+
+#if defined(__LIBCOMO__)
+    using ::mbstate_t;
+#elif defined(BOOST_DINKUMWARE_STDLIB) && !defined(__BORLANDC__)
+    using ::mbstate_t;
+#elif defined(__SGI_STL_PORT)
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+    using ::codecvt;
+    using ::mbstate_t;
+#endif
+
+} // End namespace std.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_CODECVT_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/disable_warnings.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/disable_warnings.hpp
new file mode 100644
index 0000000000..ef25cdb907
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/disable_warnings.hpp
@@ -0,0 +1,30 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#include <boost/config.hpp>             // BOOST_MSVC.
+#include <boost/detail/workaround.hpp>  // BOOST_WORKAROUND.
+
+#if defined(BOOST_MSVC)
+# pragma warning(push)
+# pragma warning(disable:4127)    // Conditional expression is constant.
+# pragma warning(disable:4130)    // Logical operation on address of string constant.
+# pragma warning(disable:4224)    // Parameter previously defined as type.
+# pragma warning(disable:4244)    // Conversion: possible loss of data.
+# pragma warning(disable:4512)    // Assignment operator could not be generated.
+# pragma warning(disable:4706)    // Assignment within conditional expression.
+# if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#  pragma warning(disable:6334)   // sizeof applied to an expression with an operator.
+# endif
+#else
+# if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+#  pragma warn -8008     // Condition always true/false.
+#  pragma warn -8066     // Unreachable code.
+#  pragma warn -8071     // Conversion may lose significant digits.
+#  pragma warn -8072     // Suspicious pointer arithmetic.
+#  pragma warn -8080     // identifier declared but never used.
+# endif
+#endif
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/dyn_link.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/dyn_link.hpp
new file mode 100644
index 0000000000..cc8c73bd90
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/dyn_link.hpp
@@ -0,0 +1,46 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Adapted from http://www.boost.org/more/separate_compilation.html, by
+// John Maddock.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_DYN_LINK_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_CONFIG_DYN_LINK_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+//------------------Enable dynamic linking on windows-------------------------// 
+
+#ifdef BOOST_HAS_DECLSPEC 
+# if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_IOSTREAMS_DYN_LINK)
+#  ifdef BOOST_IOSTREAMS_SOURCE
+#   define BOOST_IOSTREAMS_DECL __declspec(dllexport)
+#  else
+#   define BOOST_IOSTREAMS_DECL __declspec(dllimport)
+#  endif  
+# endif
+//--------------Enable dynamic linking for non-windows---------------------//
+#else // BOOST_HAS_DECLSPEC
+# if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_IOSTREAMS_DYN_LINK)
+#  ifdef BOOST_IOSTREAMS_SOURCE
+#   define BOOST_IOSTREAMS_DECL BOOST_SYMBOL_EXPORT
+#  else
+#   define BOOST_IOSTREAMS_DECL BOOST_SYMBOL_IMPORT
+#  endif
+# endif
+#endif 
+
+#ifndef BOOST_IOSTREAMS_DECL
+# define BOOST_IOSTREAMS_DECL
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_DYN_LINK_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/enable_warnings.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/enable_warnings.hpp
new file mode 100644
index 0000000000..5712f36442
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/enable_warnings.hpp
@@ -0,0 +1,18 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#if defined(BOOST_MSVC)
+# pragma warning(pop)
+#else
+# if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+#  pragma warn .8008     // Condition always true/false.
+#  pragma warn .8066     // Unreachable code.
+#  pragma warn .8071     // Conversion may lose significant digits.
+#  pragma warn .8072     // Suspicious pointer arithmetic.
+#  pragma warn .8080     // identifier declared but never used.
+# endif
+#endif
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/fpos.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/fpos.hpp
new file mode 100644
index 0000000000..a5835421fe
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/fpos.hpp
@@ -0,0 +1,45 @@
+/*
+ * 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/iostreams for documentation.
+
+ * File:        boost/iostreams/detail/execute.hpp
+ * Date:        Thu Dec 06 13:21:54 MST 2007
+ * Copyright:   2007-2008 CodeRage, LLC
+ * Author:      Jonathan Turkanis
+ * Contact:     turkanis at coderage dot com
+ *
+ * Defines the preprocessor symbol BOOST_IOSTREAMS_HAS_DINKUMWARE_FPOS for
+ * platforms that use the implementation of std::fpos from the Dinkumware
+ * Standard Library.
+ */
+
+#ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_FPOS_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_CONFIG_FPOS_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+
+# if (defined(_YVALS) || defined(_CPPLIB_VER)) && !defined(__SGI_STL_PORT) && \
+     !defined(_STLPORT_VERSION) && !defined(__QNX__) && !defined(_VX_CPU) && !defined(__VXWORKS__) \
+     && !((defined(BOOST_MSVC) || defined(BOOST_CLANG)) && _MSVC_STL_VERSION >= 141) \
+     && !defined(_LIBCPP_VERSION)
+     /**/
+
+#include <boost/iostreams/detail/ios.hpp>
+
+#  define BOOST_IOSTREAMS_HAS_DINKUMWARE_FPOS
+
+#if !defined(_FPOSOFF)
+#define BOOST_IOSTREAMS_FPOSOFF(fp) ((long long)(fp))
+#else
+#define BOOST_IOSTREAMS_FPOSOFF(fp) _FPOSOFF(fp)
+#endif
+
+# endif
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_FPOS_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/gcc.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/gcc.hpp
new file mode 100644
index 0000000000..ff6892a5e5
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/gcc.hpp
@@ -0,0 +1,27 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Adapted from <boost/config/auto_link.hpp> and from
+// http://www.boost.org/more/separate_compilation.html, by John Maddock.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_GCC_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_CONFIG_GCC_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <boost/config.hpp> // BOOST_INTEL.
+
+#if defined(__GNUC__) && !defined(BOOST_INTEL)
+# define BOOST_IOSTREAMS_GCC (__GNUC__ * 100 + __GNUC_MINOR__)
+# define BOOST_IOSTREAMS_GCC_WORKAROUND_GUARD 1
+#else
+# define BOOST_IOSTREAMS_GCC_WORKAROUND_GUARD 0
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_GCC_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/limits.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/limits.hpp
new file mode 100644
index 0000000000..155d6b0a69
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/limits.hpp
@@ -0,0 +1,19 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_LIMITS_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_CONFIG_LIMITS_HPP_INCLUDED
+
+#ifndef BOOST_IOSTREAMS_MAX_FORWARDING_ARITY
+# define BOOST_IOSTREAMS_MAX_FORWARDING_ARITY 3
+#endif
+
+#ifndef BOOST_IOSTREAMS_MAX_EXECUTE_ARITY
+# define BOOST_IOSTREAMS_MAX_EXECUTE_ARITY 5
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_LIMITS_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/overload_resolution.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/overload_resolution.hpp
new file mode 100644
index 0000000000..63d9e2830d
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/overload_resolution.hpp
@@ -0,0 +1,30 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Adapted from <boost/config/auto_link.hpp> and from
+// http://www.boost.org/more/separate_compilation.html, by John Maddock.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_BROKEN_OVERLOAD_RESOLUTION_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_CONFIG_BROKEN_OVERLOAD_RESOLUTION_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif             
+
+#include <boost/config.hpp> // BOOST_MSVC.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/detail/config/gcc.hpp>
+
+#if !defined(BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION)
+# if BOOST_WORKAROUND(__MWERKS__, <= 0x3003) || \
+     BOOST_WORKAROUND(__BORLANDC__, < 0x600) \
+     /**/
+#  define BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION
+# endif
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_BROKEN_OVERLOAD_RESOLUTION_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/rtl.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/rtl.hpp
new file mode 100644
index 0000000000..d9fbe5080d
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/rtl.hpp
@@ -0,0 +1,72 @@
+/*
+ * 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/iostreams for documentation.
+ *
+ * Defines preprocessor symbols expanding to the names of functions in the 
+ * C runtime library used to access file descriptors and to the type used
+ * to store file offsets for seeking.
+ * 
+ * File:        boost/iostreams/detail/config/rtl.hpp
+ * Date:        Wed Dec 26 11:58:11 MST 2007
+ * 
+ * Copyright:   2007-2008 CodeRage, LLC
+ * Author:      Jonathan Turkanis
+ * Contact:     turkanis at coderage dot com
+ */
+
+#ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_RTL_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_CONFIG_RTL_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/iostreams/detail/config/windows_posix.hpp>
+
+// Handle open, close, read, and write
+#ifdef __BORLANDC__
+# define BOOST_IOSTREAMS_RTL(x) BOOST_JOIN(_rtl_, x)
+#elif defined BOOST_IOSTREAMS_WINDOWS
+# define BOOST_IOSTREAMS_RTL(x) BOOST_JOIN(_, x)
+#else
+# define BOOST_IOSTREAMS_RTL(x) ::x  // Distinguish from member function named x
+#endif
+#define BOOST_IOSTREAMS_FD_OPEN   BOOST_IOSTREAMS_RTL(open)
+#define BOOST_IOSTREAMS_FD_CLOSE  BOOST_IOSTREAMS_RTL(close)
+#define BOOST_IOSTREAMS_FD_READ   BOOST_IOSTREAMS_RTL(read)
+#define BOOST_IOSTREAMS_FD_WRITE  BOOST_IOSTREAMS_RTL(write)
+
+// Handle lseek, off_t, ftruncate, and stat
+#ifdef BOOST_IOSTREAMS_WINDOWS
+# if defined(BOOST_MSVC) || defined(__MSVCRT__) // MSVC, MinGW
+#  define BOOST_IOSTREAMS_FD_SEEK    _lseeki64
+#  define BOOST_IOSTREAMS_FD_OFFSET  __int64
+# else                                          // Borland, Metrowerks, ...
+#  define BOOST_IOSTREAMS_FD_SEEK    lseek  
+#  define BOOST_IOSTREAMS_FD_OFFSET  long
+# endif
+#else // Non-windows
+# if defined(_LARGEFILE64_SOURCE) && !defined(__APPLE__) && \
+         (!defined(_FILE_OFFSET_BITS) || _FILE_OFFSET_BITS != 64) || \
+     defined(_AIX) && !defined(_LARGE_FILES) || \
+     defined(BOOST_IOSTREAMS_HAS_LARGE_FILE_EXTENSIONS)
+     /**/
+
+    /* Systems with transitional extensions for large file support */
+
+#  define BOOST_IOSTREAMS_FD_SEEK      lseek64
+#  define BOOST_IOSTREAMS_FD_TRUNCATE  ftruncate64
+#  define BOOST_IOSTREAMS_FD_MMAP      mmap64
+#  define BOOST_IOSTREAMS_FD_STAT      stat64
+#  define BOOST_IOSTREAMS_FD_FSTAT     fstat64
+#  define BOOST_IOSTREAMS_FD_OFFSET    off64_t
+# else
+#  define BOOST_IOSTREAMS_FD_SEEK      lseek
+#  define BOOST_IOSTREAMS_FD_TRUNCATE  ftruncate
+#  define BOOST_IOSTREAMS_FD_MMAP      mmap
+#  define BOOST_IOSTREAMS_FD_STAT      stat
+#  define BOOST_IOSTREAMS_FD_FSTAT     fstat
+#  define BOOST_IOSTREAMS_FD_OFFSET    off_t
+# endif
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_RTL_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/unreachable_return.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/unreachable_return.hpp
new file mode 100644
index 0000000000..65fba609de
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/unreachable_return.hpp
@@ -0,0 +1,24 @@
+// (C) Copyright 2010 Daniel James
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_UNREACHABLE_RETURN_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_UNREACHABLE_RETURN_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <boost/config.hpp>
+
+#if defined(_MSC_VER) || defined(__GNUC__)
+#define BOOST_IOSTREAMS_UNREACHABLE_RETURN(x) \
+    BOOST_UNREACHABLE_RETURN(x)
+#else
+#define BOOST_IOSTREAMS_UNREACHABLE_RETURN(x) \
+    return x;
+#endif
+
+#endif
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/wide_streams.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/wide_streams.hpp
new file mode 100644
index 0000000000..af3d716d49
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/wide_streams.hpp
@@ -0,0 +1,55 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Adapted from http://www.boost.org/more/separate_compilation.html, by
+// John Maddock.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_WIDE_STREAMS_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_CONFIG_WIDE_STREAMS_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <cstddef>
+
+#if defined(_MSC_VER)
+# pragma once
+#endif       
+
+//------------------Templated stream support----------------------------------//
+
+// From boost/dynamic_bitset.hpp; thanks to Matthias Troyer for cray patch.
+#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
+# if defined(__STL_CONFIG_H) && \
+    !defined (__STL_USE_NEW_IOSTREAMS) && !defined(__crayx1) \
+    /**/
+#  define BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
+# endif
+#endif // #ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
+
+//------------------Wide stream support---------------------------------------//
+
+#ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS
+# if defined(BOOST_IOSTREAMS_NO_STREAM_TEMPLATES) || \
+     defined (BOOST_NO_STD_WSTREAMBUF) && \
+     ( !defined(__MSL_CPP__) || defined(_MSL_NO_WCHART_CPP_SUPPORT) ) \
+     /**/
+#  define BOOST_IOSTREAMS_NO_WIDE_STREAMS
+# endif
+#endif // #ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS   
+
+//------------------Locale support--------------------------------------------//
+
+#ifndef BOOST_IOSTREAMS_NO_LOCALE
+# if defined(BOOST_NO_STD_LOCALE) || \
+     defined(__CYGWIN__) && \
+     ( !defined(__MSL_CPP__) || defined(_MSL_NO_WCHART_CPP_SUPPORT) ) \
+     /**/
+#  define BOOST_IOSTREAMS_NO_LOCALE
+# endif
+#endif // #ifndef BOOST_IOSTREAMS_NO_LOCALE
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_WIDE_STREAMS_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/windows_posix.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/windows_posix.hpp
new file mode 100644
index 0000000000..4e73c50d0d
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/windows_posix.hpp
@@ -0,0 +1,25 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2004-2007 Jonathan Turkanis
+// (C) Copyright 2002, 2003 Beman Dawes   Boost.Filesystem
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_WINDOWS_POSIX_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_CONFIG_WINDOWS_POSIX_HPP_INCLUDED
+
+//------------------From boost/libs/filesystem/src/path_posix_windows.cpp-----//
+
+// BOOST_IOSTREAMS_POSIX or BOOST_IOSTREAMS_WINDOWS specify which API to use.
+#if !defined( BOOST_IOSTREAMS_WINDOWS ) && !defined( BOOST_IOSTREAMS_POSIX )
+# if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32)) && \
+     !defined(__CYGWIN__) \
+     /**/
+#  define BOOST_IOSTREAMS_WINDOWS
+# else
+#  define BOOST_IOSTREAMS_POSIX
+# endif
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_WINDOWS_POSIX_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/zlib.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/zlib.hpp
new file mode 100644
index 0000000000..017dd0c182
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/config/zlib.hpp
@@ -0,0 +1,50 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Adapted from <boost/config/auto_link.hpp> and from
+// http://www.boost.org/more/separate_compilation.html, by John Maddock.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_ZLIB_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_CONFIG_ZLIB_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp> // BOOST_STRINGIZE.
+
+#if defined(BOOST_ZLIB_BINARY)
+# if defined(BOOST_MSVC) || \
+     defined(__BORLANDC__) || \
+     (defined(__MWERKS__) && defined(_WIN32) && (__MWERKS__ >= 0x3000)) || \
+     (defined(__ICL) && defined(_MSC_EXTENSIONS)) \
+     /**/
+
+// Specify the name of the .lib file.
+#  pragma comment(lib, BOOST_STRINGIZE(BOOST_ZLIB_BINARY))
+# endif
+#else 
+# if !defined(BOOST_IOSTREAMS_SOURCE) && \
+     !defined(BOOST_ALL_NO_LIB) && \
+     !defined(BOOST_IOSTREAMS_NO_LIB) \
+     /**/
+
+// 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_zlib
+
+// If we're importing code from a dll, then tell auto_link.hpp about it.
+#  if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_IOSTREAMS_DYN_LINK)
+#   define BOOST_DYN_LINK
+#  endif
+
+// And include the header that does the work.
+#  include <boost/config/auto_link.hpp>
+# endif
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_ZLIB_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/default_arg.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/default_arg.hpp
new file mode 100644
index 0000000000..c443e9872a
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/default_arg.hpp
@@ -0,0 +1,21 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2005-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_DEFAULT_ARG_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_DEFAULT_ARG_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif            
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+// Obsolete. Remove.
+#define BOOST_IOSTREAMS_DEFAULT_ARG(arg) arg
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_DEFAULT_ARG_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/dispatch.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/dispatch.hpp
new file mode 100644
index 0000000000..35cf244141
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/dispatch.hpp
@@ -0,0 +1,41 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_DISPATCH_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_DISPATCH_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <boost/config.hpp>                   // BOOST_DEDUCED_TYPENAME. 
+#include <boost/iostreams/detail/select.hpp>
+#include <boost/iostreams/traits.hpp>         // category_of. 
+#include <boost/mpl/void.hpp>          
+#include <boost/type_traits/is_convertible.hpp>         
+
+namespace boost { namespace iostreams {namespace detail {
+    
+template< typename T, typename Tag1, typename Tag2,
+          typename Tag3 = mpl::void_, typename Tag4 = mpl::void_,
+          typename Tag5 = mpl::void_, typename Tag6 = mpl::void_,
+          typename Category = 
+              BOOST_DEDUCED_TYPENAME category_of<T>::type >
+struct dispatch 
+    : iostreams::select<  // Disambiguation for Tru64.
+          is_convertible<Category, Tag1>, Tag1,
+          is_convertible<Category, Tag2>, Tag2,
+          is_convertible<Category, Tag3>, Tag3,
+          is_convertible<Category, Tag4>, Tag4,
+          is_convertible<Category, Tag5>, Tag5,
+          is_convertible<Category, Tag6>, Tag6
+      >
+    { };
+
+} } } // End namespaces detail, iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_DISPATCH_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/double_object.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/double_object.hpp
new file mode 100644
index 0000000000..efb3b78601
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/double_object.hpp
@@ -0,0 +1,114 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2004-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Contains the definition of the class template 
+// boost::iostreams::detail::double_object, which is similar to compressed pair
+// except that both members of the pair have the same type, and 
+// compression occurs only if requested using a boolean template
+// parameter.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_DOUBLE_OBJECT_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_DOUBLE_OBJECT_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <algorithm>              // swap.
+#include <boost/detail/workaround.hpp>
+#include <boost/mpl/if.hpp>
+#if BOOST_WORKAROUND(__MWERKS__, > 0x3003)
+# include <msl_utility>
+#else
+# include <boost/call_traits.hpp>
+#endif
+
+namespace boost { namespace iostreams { namespace detail {
+
+template<typename T>
+class single_object_holder {
+public:
+#if BOOST_WORKAROUND(__MWERKS__, > 0x3003)
+    typedef Metrowerks::call_traits<T>             traits_type;
+#else
+    typedef boost::call_traits<T>                  traits_type;
+#endif
+    typedef typename traits_type::param_type       param_type;
+    typedef typename traits_type::reference        reference;
+    typedef typename traits_type::const_reference  const_reference;
+    single_object_holder() { }
+    single_object_holder(param_type t) : first_(t) { }
+    reference first() { return first_; }
+    const_reference first() const { return first_; }
+    reference second() { return first_; }
+    const_reference second() const { return first_; }
+    void swap(single_object_holder& o)
+    { std::swap(first_, o.first_); }
+private:
+    T first_;
+};
+
+template<typename T>
+struct double_object_holder {
+public:
+#if BOOST_WORKAROUND(__MWERKS__, > 0x3003)
+    typedef Metrowerks::call_traits<T>             traits_type;
+#else
+    typedef boost::call_traits<T>                  traits_type;
+#endif
+    typedef typename traits_type::param_type       param_type;
+    typedef typename traits_type::reference        reference;
+    typedef typename traits_type::const_reference  const_reference;
+    double_object_holder() { }
+    double_object_holder(param_type t1, param_type t2)
+        : first_(t1), second_(t2) { }
+    reference first() { return first_; }
+    const_reference first() const { return first_; }
+    reference second() { return second_; }
+    const_reference second() const { return second_; }
+    void swap(double_object_holder& d)
+    { 
+        std::swap(first_, d.first_); 
+        std::swap(second_, d.second_); 
+    }
+private:
+    T first_, second_;
+};
+
+template<typename T, typename IsDouble>
+class double_object 
+    : public mpl::if_<
+                 IsDouble, 
+                 double_object_holder<T>, 
+                 single_object_holder<T>
+             >::type
+{
+private:
+    typedef typename 
+            mpl::if_<
+                IsDouble, 
+                double_object_holder<T>, 
+                single_object_holder<T>
+            >::type                                base_type;
+public:
+#if BOOST_WORKAROUND(__MWERKS__, > 0x3003)
+    typedef Metrowerks::call_traits<T>             traits_type;
+#else
+    typedef boost::call_traits<T>                  traits_type;
+#endif
+    typedef typename traits_type::param_type       param_type;
+    typedef typename traits_type::reference        reference;
+    typedef typename traits_type::const_reference  const_reference;
+    double_object() : base_type() {}
+    double_object(param_type t1, param_type t2)
+        : base_type(t1, t2) { }
+    bool is_double() const { return IsDouble::value; }
+};
+
+} } } // End namespaces detail, iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_DOUBLE_OBJECT_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/enable_if_stream.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/enable_if_stream.hpp
new file mode 100644
index 0000000000..826e44d2a5
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/enable_if_stream.hpp
@@ -0,0 +1,32 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_ENABLE_IF_STREAM_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_ENABLE_IF_STREAM_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <boost/config.hpp>                // BOOST_NO_SFINAE.
+#include <boost/utility/enable_if.hpp>                  
+#include <boost/iostreams/traits_fwd.hpp>  // is_std_io.
+
+#if !defined(BOOST_NO_SFINAE) && \
+    !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+# define BOOST_IOSTREAMS_ENABLE_IF_STREAM(T) \
+    , typename boost::enable_if< boost::iostreams::is_std_io<T> >::type* = 0 \
+    /**/
+# define BOOST_IOSTREAMS_DISABLE_IF_STREAM(T) \
+    , typename boost::disable_if< boost::iostreams::is_std_io<T> >::type* = 0 \
+    /**/
+#else 
+# define BOOST_IOSTREAMS_ENABLE_IF_STREAM(T)
+# define BOOST_IOSTREAMS_DISABLE_IF_STREAM(T)
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_ENABLE_IF_STREAM_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/error.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/error.hpp
new file mode 100644
index 0000000000..85cbd98fe2
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/error.hpp
@@ -0,0 +1,45 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_ERROR_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_ERROR_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+                 
+#include <boost/iostreams/detail/ios.hpp>  // failure.
+
+namespace boost { namespace iostreams { namespace detail {
+
+inline BOOST_IOSTREAMS_FAILURE cant_read() 
+{ return BOOST_IOSTREAMS_FAILURE("no read access"); }
+
+inline BOOST_IOSTREAMS_FAILURE cant_write() 
+{ return BOOST_IOSTREAMS_FAILURE("no write access"); }
+
+inline BOOST_IOSTREAMS_FAILURE cant_seek() 
+{ return BOOST_IOSTREAMS_FAILURE("no random access"); }
+
+inline BOOST_IOSTREAMS_FAILURE bad_read() 
+{ return BOOST_IOSTREAMS_FAILURE("bad read"); }
+
+inline BOOST_IOSTREAMS_FAILURE bad_putback() 
+{ return BOOST_IOSTREAMS_FAILURE("putback buffer full"); }
+
+inline BOOST_IOSTREAMS_FAILURE bad_write() 
+{ return BOOST_IOSTREAMS_FAILURE("bad write"); }
+
+inline BOOST_IOSTREAMS_FAILURE write_area_exhausted() 
+{ return BOOST_IOSTREAMS_FAILURE("write area exhausted"); }
+
+inline BOOST_IOSTREAMS_FAILURE bad_seek() 
+{ return BOOST_IOSTREAMS_FAILURE("bad seek"); }
+
+} } } // End namespaces detail, iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_ERROR_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/execute.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/execute.hpp
new file mode 100644
index 0000000000..28e4217234
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/execute.hpp
@@ -0,0 +1,135 @@
+/*
+ * 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/iostreams for documentation.
+
+ * File:        boost/iostreams/detail/execute.hpp
+ * Date:        Thu Dec 06 13:21:54 MST 2007
+ * Copyright:   2007-2008 CodeRage, LLC
+ * Author:      Jonathan Turkanis
+ * Contact:     turkanis at coderage dot com
+
+ * Defines the overloaded function template 
+ * boost::iostreams::detail::execute_all() and the function template 
+ * boost::iostreams::detail::execute_foreach().
+ *
+ * execute_all() invokes a primary operation and performs a sequence of cleanup 
+ * operations, returning the result of the primary operation if no exceptions
+ * are thrown. If one of the operations throws an exception, performs the
+ * remaining operations and rethrows the initial exception.
+ *
+ * execute_foreach() is a variant of std::foreach which invokes a function 
+ * object for each item in a sequence, catching all execptions and rethrowing
+ * the first caught exception after the function object has been invoked on each
+ * item.
+ */
+
+#ifndef BOOST_IOSTREAMS_DETAIL_EXECUTE_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_EXECUTE_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/detail/config/limits.hpp>   // MAX_EXECUTE_ARITY
+#include <boost/preprocessor/arithmetic/dec.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/iteration/local.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+#include <boost/utility/result_of.hpp>
+
+namespace boost { namespace iostreams { namespace detail {
+
+// Helper for class template execute_traits.
+template<typename Result>
+struct execute_traits_impl {
+    typedef Result result_type;
+    template<typename Op>
+    static Result execute(Op op) { return op(); }
+};
+
+// Specialization for void return. For simplicity, execute() returns int 
+// for operations returning void. This could be avoided with additional work.
+template<>
+struct execute_traits_impl<void> {
+    typedef int result_type;
+    template<typename Op>
+    static int execute(Op op) { op(); return 0; }
+};
+
+// Deduces the result type of Op and allows uniform treatment of operations 
+// returning void and non-void.
+template< typename Op, 
+          typename Result = // VC6.5 workaround.
+              #if !defined(BOOST_NO_RESULT_OF) && \
+                  !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+                  typename boost::result_of<Op()>::type
+              #else
+                  BOOST_DEDUCED_TYPENAME Op::result_type
+              #endif
+          >
+struct execute_traits 
+    : execute_traits_impl<Result>
+    { };
+
+// Implementation with no cleanup operations.
+template<typename Op>
+typename execute_traits<Op>::result_type 
+execute_all(Op op) 
+{ 
+    return execute_traits<Op>::execute(op);
+}
+
+// Implementation with one or more cleanup operations
+#define BOOST_PP_LOCAL_MACRO(n) \
+   template<typename Op, BOOST_PP_ENUM_PARAMS(n, typename C)> \
+   typename execute_traits<Op>::result_type \
+   execute_all(Op op, BOOST_PP_ENUM_BINARY_PARAMS(n, C, c)) \
+   { \
+       typename execute_traits<Op>::result_type r; \
+       try { \
+           r = boost::iostreams::detail::execute_all( \
+                   op BOOST_PP_COMMA_IF(BOOST_PP_DEC(n)) \
+                   BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(n), c) \
+               ); \
+       } catch (...) { \
+           try { \
+               BOOST_PP_CAT(c, BOOST_PP_DEC(n))(); \
+           } catch (...) { } \
+           throw; \
+       } \
+       BOOST_PP_CAT(c, BOOST_PP_DEC(n))(); \
+       return r; \
+   } \
+   /**/
+
+#define BOOST_PP_LOCAL_LIMITS (1, BOOST_IOSTREAMS_MAX_EXECUTE_ARITY)
+#include BOOST_PP_LOCAL_ITERATE()
+#undef BOOST_PP_LOCAL_MACRO
+
+template<class InIt, class Op>
+Op execute_foreach(InIt first, InIt last, Op op)
+{
+    if (first == last)
+        return op;
+    try {
+        op(*first);
+    } catch (...) {
+        try {
+            ++first;
+            boost::iostreams::detail::execute_foreach(first, last, op);
+        } catch (...) { }
+        throw;
+    }
+    ++first;
+    return boost::iostreams::detail::execute_foreach(first, last, op);
+}
+
+} } } // End namespaces detail, iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_EXECUTE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/file_handle.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/file_handle.hpp
new file mode 100644
index 0000000000..d797efb29a
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/file_handle.hpp
@@ -0,0 +1,32 @@
+/*
+ * 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/iostreams for documentation.
+ *
+ * File:        boost/iostreams/detail/file_handle.hpp
+ * Date:        Sun Jun 22 14:23:12 MDT 2008
+ * Copyright:   2008 CodeRage, LLC
+ * Author:      Jonathan Turkanis
+ * Contact:     turkanis at coderage dot com
+ *
+ * Defines the type boost::iostreams::detail::file_handle, representing an
+ * operating system file handle.
+ */
+
+#ifndef BOOST_IOSTREAMS_DETAIL_FILE_HANDLE_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_FILE_HANDLE_HPP_INCLUDED
+
+#include <boost/iostreams/detail/config/windows_posix.hpp>
+
+namespace boost { namespace iostreams { namespace detail {
+
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    typedef void*  file_handle;  // A.k.a. HANDLE
+#else
+    typedef int    file_handle;
+#endif
+
+} } } // End namespaces detail, iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_FILE_HANDLE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/forward.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/forward.hpp
new file mode 100644
index 0000000000..f5ed4f85dc
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/forward.hpp
@@ -0,0 +1,113 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_FORWARD_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_FORWARD_HPP_INCLUDED   
+
+#if defined(_MSC_VER)
+# pragma once
+#endif                  
+ 
+#include <boost/config.hpp> // BOOST_MSVC, BOOST_NO_SFINAE
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/detail/config/limits.hpp>
+#include <boost/iostreams/detail/push_params.hpp>
+#include <boost/preprocessor/arithmetic/dec.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/preprocessor/tuple/elem.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+//------Macros for defining forwarding constructors and open overloads--------//
+    
+//
+// Macro: BOOST_IOSTREAMS_FORWARD(class, impl, device, params, args)
+// Description: Defines constructors and overloads of 'open' which construct
+//      a device using the specified argument list and pass it to the specified
+//      helper function
+//   class - The class name
+//   impl - The helper function
+//   device - The device type
+//   params - The list of formal parameters trailing the device parameter in
+//     the helper function's signature
+//   params - The list of arguments passed to the helper function, following the
+//     device argument
+//
+#define BOOST_IOSTREAMS_FORWARD(class, impl, device, params, args) \
+    class(const device& t params()) \
+    { this->impl(::boost::iostreams::detail::wrap(t) args()); } \
+    class(device& t params()) \
+    { this->impl(::boost::iostreams::detail::wrap(t) args()); } \
+    class(const ::boost::reference_wrapper<device>& ref params()) \
+    { this->impl(ref args()); } \
+    void open(const device& t params()) \
+    { this->impl(::boost::iostreams::detail::wrap(t) args()); } \
+    void open(device& t params()) \
+    { this->impl(::boost::iostreams::detail::wrap(t) args()); } \
+    void open(const ::boost::reference_wrapper<device>& ref params()) \
+    { this->impl(ref args()); } \
+    BOOST_PP_REPEAT_FROM_TO( \
+        1, BOOST_PP_INC(BOOST_IOSTREAMS_MAX_FORWARDING_ARITY), \
+        BOOST_IOSTREAMS_FORWARDING_CTOR, (class, impl, device) \
+    ) \
+    BOOST_PP_REPEAT_FROM_TO( \
+        1, BOOST_PP_INC(BOOST_IOSTREAMS_MAX_FORWARDING_ARITY), \
+        BOOST_IOSTREAMS_FORWARDING_FN, (class, impl, device) \
+    ) \
+    /**/
+#define BOOST_IOSTREAMS_FORWARDING_CTOR(z, n, tuple) \
+    template<BOOST_PP_ENUM_PARAMS_Z(z, n, typename U)> \
+    BOOST_PP_TUPLE_ELEM(3, 0, tuple) \
+    (BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, const U, &u) \
+      BOOST_IOSTREAMS_DISABLE_IF_SAME(U0, BOOST_PP_TUPLE_ELEM(3, 2, tuple))) \
+    { this->BOOST_PP_TUPLE_ELEM(3, 1, tuple) \
+      ( BOOST_PP_TUPLE_ELEM(3, 2, tuple) \
+        (BOOST_PP_ENUM_PARAMS_Z(z, n, u)) ); } \
+    template< typename U100 BOOST_PP_COMMA_IF(BOOST_PP_DEC(n)) \
+              BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_DEC(n), typename U) > \
+    BOOST_PP_TUPLE_ELEM(3, 0, tuple) \
+    ( U100& u100 BOOST_PP_COMMA_IF(BOOST_PP_DEC(n)) \
+      BOOST_PP_ENUM_BINARY_PARAMS_Z(z, BOOST_PP_DEC(n), const U, &u) \
+      BOOST_IOSTREAMS_DISABLE_IF_SAME(U100, BOOST_PP_TUPLE_ELEM(3, 2, tuple))) \
+    { this->BOOST_PP_TUPLE_ELEM(3, 1, tuple) \
+      ( BOOST_PP_TUPLE_ELEM(3, 2, tuple) \
+        ( u100 BOOST_PP_COMMA_IF(BOOST_PP_DEC(n)) \
+          BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_DEC(n), u)) ); } \
+    /**/
+#define BOOST_IOSTREAMS_FORWARDING_FN(z, n, tuple) \
+    template<BOOST_PP_ENUM_PARAMS_Z(z, n, typename U)> \
+    void open(BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, const U, &u) \
+      BOOST_IOSTREAMS_DISABLE_IF_SAME(U0, BOOST_PP_TUPLE_ELEM(3, 2, tuple))) \
+    { this->BOOST_PP_TUPLE_ELEM(3, 1, tuple) \
+      ( BOOST_PP_TUPLE_ELEM(3, 2, tuple) \
+        (BOOST_PP_ENUM_PARAMS_Z(z, n, u)) ); } \
+    template< typename U100 BOOST_PP_COMMA_IF(BOOST_PP_DEC(n)) \
+              BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_DEC(n), typename U) > \
+    void open \
+    ( U100& u100 BOOST_PP_COMMA_IF(BOOST_PP_DEC(n)) \
+      BOOST_PP_ENUM_BINARY_PARAMS_Z(z, BOOST_PP_DEC(n), const U, &u) \
+      BOOST_IOSTREAMS_DISABLE_IF_SAME(U100, BOOST_PP_TUPLE_ELEM(3, 2, tuple))) \
+    { this->BOOST_PP_TUPLE_ELEM(3, 1, tuple) \
+      ( u100 BOOST_PP_COMMA_IF(BOOST_PP_DEC(n)) \
+        BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_DEC(n), u) ); } \
+    /**/
+
+// Disable forwarding constructors if first parameter type is the same
+// as the device type
+#if !defined(BOOST_NO_SFINAE) && \
+    !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+# define BOOST_IOSTREAMS_DISABLE_IF_SAME(device, param) \
+    , typename boost::disable_if< boost::is_same<device, param> >::type* = 0 \
+    /**/
+#else 
+# define BOOST_IOSTREAMS_DISABLE_IF_SAME(device, param)
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_FORWARD_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/fstream.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/fstream.hpp
new file mode 100644
index 0000000000..848258d97c
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/fstream.hpp
@@ -0,0 +1,33 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_FSTREAM_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_FSTREAM_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+                 
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
+# include <fstream>
+#else
+# include <fstream.h>
+#endif 
+
+#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
+# define BOOST_IOSTREAMS_BASIC_IFSTREAM(Ch, Tr) std::basic_ifstream<Ch, Tr>
+# define BOOST_IOSTREAMS_BASIC_OFSTREAM(Ch, Tr) std::basic_ofstream<Ch, Tr>
+# define BOOST_IOSTREAMS_BASIC_FSTREAM(Ch, Tr) std::basic_fstream<Ch, Tr>
+# define BOOST_IOSTREAMS_BASIC_FILEBUF(Ch) std::basic_filebuf<Ch>
+#else 
+# define BOOST_IOSTREAMS_BASIC_IFSTREAM(Ch, Tr) std::ifstream
+# define BOOST_IOSTREAMS_BASIC_OFSTREAM(Ch, Tr) std::ofstream
+# define BOOST_IOSTREAMS_BASIC_FILEBUF(Ch) std::filebuf
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_FSTREAM_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/functional.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/functional.hpp
new file mode 100644
index 0000000000..7f345f5a86
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/functional.hpp
@@ -0,0 +1,192 @@
+/*
+ * 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/iostreams for documentation.
+
+ * File:        boost/iostreams/detail/functional.hpp
+ * Date:        Sun Dec 09 05:38:03 MST 2007
+ * Copyright:   2007-2008 CodeRage, LLC
+ * Author:      Jonathan Turkanis
+ * Contact:     turkanis at coderage dot com
+
+ * Defines several function objects and object generators for use with 
+ * execute_all()
+ */
+
+#ifndef BOOST_IOSTREAMS_DETAIL_FUNCTIONAL_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_FUNCTIONAL_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/iostreams/close.hpp>
+#include <boost/iostreams/detail/ios.hpp> // BOOST_IOS
+
+namespace boost { namespace iostreams { namespace detail {
+
+    // Function objects and object generators for invoking
+    // boost::iostreams::close
+
+template<typename T>
+class device_close_operation {
+public:
+    typedef void result_type;
+    device_close_operation(T& t, BOOST_IOS::openmode which) 
+        : t_(t), which_(which) 
+        { }
+    void operator()() const { boost::iostreams::close(t_, which_); }
+private:
+    BOOST_DELETED_FUNCTION(device_close_operation& operator=(const device_close_operation&));
+    T&                   t_;
+    BOOST_IOS::openmode  which_;
+};
+
+template<typename T, typename Sink>
+class filter_close_operation {
+public:
+    typedef void result_type;
+    filter_close_operation(T& t, Sink& snk, BOOST_IOS::openmode which)
+        : t_(t), snk_(snk), which_(which)
+        { }
+    void operator()() const { boost::iostreams::close(t_, snk_, which_); }
+private:
+    BOOST_DELETED_FUNCTION(filter_close_operation& operator=(const filter_close_operation&));
+    T&                   t_;
+    Sink&                snk_;
+    BOOST_IOS::openmode  which_;
+};
+
+template<typename T>
+device_close_operation<T> 
+call_close(T& t, BOOST_IOS::openmode which) 
+{ return device_close_operation<T>(t, which); }
+
+template<typename T, typename Sink>
+filter_close_operation<T, Sink> 
+call_close(T& t, Sink& snk, BOOST_IOS::openmode which) 
+{ return filter_close_operation<T, Sink>(t, snk, which); }
+
+    // Function objects and object generators for invoking
+    // boost::iostreams::detail::close_all
+
+template<typename T>
+class device_close_all_operation {
+public:
+    typedef void result_type;
+    device_close_all_operation(T& t) : t_(t) { }
+    device_close_all_operation(const device_close_all_operation& ohter) = default;
+    void operator()() const { detail::close_all(t_); }
+private:
+    BOOST_DELETED_FUNCTION(device_close_all_operation& operator=(const device_close_all_operation&));
+    T& t_;
+};
+
+template<typename T, typename Sink>
+class filter_close_all_operation {
+public:
+    typedef void result_type;
+    filter_close_all_operation(T& t, Sink& snk) : t_(t), snk_(snk) { }
+    void operator()() const { detail::close_all(t_, snk_); }
+private:
+    BOOST_DELETED_FUNCTION(filter_close_all_operation& operator=(const filter_close_all_operation&));
+    T&     t_;
+    Sink&  snk_;
+};
+
+template<typename T>
+device_close_all_operation<T> call_close_all(T& t) 
+{ return device_close_all_operation<T>(t); }
+
+template<typename T, typename Sink>
+filter_close_all_operation<T, Sink> 
+call_close_all(T& t, Sink& snk) 
+{ return filter_close_all_operation<T, Sink>(t, snk); }
+
+    // Function object and object generator for invoking a
+    // member function void close(std::ios_base::openmode)
+
+template<typename T>
+class member_close_operation {
+public:
+    typedef void result_type;
+    member_close_operation(T& t, BOOST_IOS::openmode which) 
+        : t_(t), which_(which) 
+        { }
+    void operator()() const { t_.close(which_); }
+    member_close_operation(member_close_operation const& other) = default;
+private:
+    BOOST_DELETED_FUNCTION(member_close_operation& operator=(const member_close_operation&));
+    T&                   t_;
+    BOOST_IOS::openmode  which_;
+};
+
+template<typename T>
+member_close_operation<T> call_member_close(T& t, BOOST_IOS::openmode which) 
+{ return member_close_operation<T>(t, which); }
+
+    // Function object and object generator for invoking a
+    // member function void reset()
+
+template<typename T>
+class reset_operation {
+public:
+    reset_operation(T& t) : t_(t) { }
+    reset_operation(reset_operation const& other) = default;
+    void operator()() const { t_.reset(); }
+private:
+    BOOST_DELETED_FUNCTION(reset_operation& operator=(const reset_operation&));
+    T& t_;
+};
+
+template<typename T>
+reset_operation<T> call_reset(T& t) { return reset_operation<T>(t); }
+
+    // Function object and object generator for clearing a flag
+
+template<typename T>
+class clear_flags_operation {
+public:
+    typedef void result_type;
+    clear_flags_operation(T& t) : t_(t) { }
+    void operator()() const { t_ = 0; }
+private:
+    BOOST_DELETED_FUNCTION(clear_flags_operation& operator=(const clear_flags_operation&));
+    T& t_;
+};
+
+template<typename T>
+clear_flags_operation<T> clear_flags(T& t) 
+{ return clear_flags_operation<T>(t); }
+
+    // Function object and generator for flushing a buffer
+
+// Function object for use with execute_all()
+template<typename Buffer, typename Device>
+class flush_buffer_operation {
+public:
+    typedef void result_type;
+    flush_buffer_operation(Buffer& buf, Device& dev, bool flush)
+        : buf_(buf), dev_(dev), flush_(flush)
+        { }
+    void operator()() const
+    {
+        if (flush_) 
+            buf_.flush(dev_);
+    }
+private:
+    BOOST_DELETED_FUNCTION(flush_buffer_operation& operator=(const flush_buffer_operation&));
+    Buffer&  buf_;
+    Device&  dev_;
+    bool     flush_;
+};
+
+template<typename Buffer, typename Device>
+flush_buffer_operation<Buffer, Device> 
+flush_buffer(Buffer& buf, Device& dev, bool flush)
+{ return flush_buffer_operation<Buffer, Device>(buf, dev, flush); }
+
+} } } // End namespaces detail, iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_FUNCTIONAL_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/ios.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/ios.hpp
new file mode 100644
index 0000000000..b123ddeb58
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/ios.hpp
@@ -0,0 +1,65 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_IOS_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_IOS_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+                 
+#include <boost/config.hpp> // BOOST_MSVC.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
+# if !BOOST_WORKAROUND(__MWERKS__, <= 0x3003)
+#  include <ios>
+# else
+#  include <istream>
+#  include <ostream>
+# endif
+#else 
+# include <exception>
+# include <iosfwd>
+#endif 
+
+namespace boost { namespace iostreams { namespace detail {
+
+#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //--------------------------------//
+# define BOOST_IOSTREAMS_BASIC_IOS(ch, tr)  std::basic_ios< ch, tr >
+# if !BOOST_WORKAROUND(__MWERKS__, <= 0x3003) && \
+     !BOOST_WORKAROUND(__BORLANDC__, < 0x600) \
+     /**/
+
+#define BOOST_IOS                std::ios
+#define BOOST_IOSTREAMS_FAILURE  std::ios::failure
+
+# else
+
+#define BOOST_IOS                std::ios_base
+#define BOOST_IOSTREAMS_FAILURE  std::ios_base::failure
+
+# endif
+#else // #ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //-----------------------//
+
+#define BOOST_IOS                          std::ios
+#define BOOST_IOSTREAMS_BASIC_IOS(ch, tr)  std::ios
+#define BOOST_IOSTREAMS_FAILURE            boost::iostreams::detail::failure
+
+class failure : std::exception {    
+public:
+    explicit failure(const std::string& what_arg) : what_(what_arg) { }
+    const char* what() const { return what_.c_str(); }
+private:
+    std::string what_;
+};
+
+#endif // #ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //----------------------//
+
+} } } // End namespace failure, iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_IOS_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/iostream.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/iostream.hpp
new file mode 100644
index 0000000000..1e19f08278
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/iostream.hpp
@@ -0,0 +1,34 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_IOSTREAM_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_IOSTREAM_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+                 
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
+# include <istream>
+# include <ostream>
+#else
+# include <iostream.h>
+#endif
+
+#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
+# define BOOST_IOSTREAMS_BASIC_ISTREAM(ch, tr) std::basic_istream< ch, tr >
+# define BOOST_IOSTREAMS_BASIC_OSTREAM(ch, tr) std::basic_ostream< ch, tr >
+# define BOOST_IOSTREAMS_BASIC_IOSTREAM(ch, tr) std::basic_iostream< ch, tr >
+#else
+# define BOOST_IOSTREAMS_BASIC_STREAMBUF(ch, tr) std::streambuf
+# define BOOST_IOSTREAMS_BASIC_ISTREAM(ch, tr) std::istream
+# define BOOST_IOSTREAMS_BASIC_OSTREAM(ch, tr) std::ostream
+# define BOOST_IOSTREAMS_BASIC_IOSTREAM(ch, tr) std::iostream
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_IOSTREAM_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/is_dereferenceable.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/is_dereferenceable.hpp
new file mode 100644
index 0000000000..06744abbdf
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/is_dereferenceable.hpp
@@ -0,0 +1,80 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2005-2007 Jonathan Turkanis
+// (C) Copyright David Abrahams 2004.
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_IS_DEREFERENCEABLE_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_IS_DEREFERENCEABLE_HPP_INCLUDED
+
+# include <boost/type_traits/remove_cv.hpp>
+# include <boost/mpl/aux_/lambda_support.hpp>
+# include <boost/mpl/bool.hpp>
+# include <boost/detail/workaround.hpp>
+
+namespace boost { namespace iostreams { namespace detail { 
+
+// is_dereferenceable<T> metafunction
+//
+// Requires: Given x of type T&, if the expression *x is well-formed
+// it must have complete type; otherwise, it must neither be ambiguous
+// nor violate access.
+
+// This namespace ensures that ADL doesn't mess things up.
+namespace is_dereferenceable_
+{
+  // a type returned from operator* when no increment is found in the
+  // type's own namespace
+  struct tag {};
+  
+  // any soaks up implicit conversions and makes the following
+  // operator* less-preferred than any other such operator that
+  // might be found via ADL.
+  struct any { template <class T> any(T const&); };
+
+  // This is a last-resort operator* for when none other is found
+  tag operator*(any const&);
+
+# if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202))
+#  define BOOST_comma(a,b) (a)
+# else 
+  // In case an operator++ is found that returns void, we'll use ++x,0
+  tag operator,(tag,int);  
+#  define BOOST_comma(a,b) (a,b)
+# endif 
+  
+  // two check overloads help us identify which operator++ was picked
+  char (& check_increment(tag) )[2];
+  
+  template <class T>
+  char check_increment(T const&);
+  
+  template <class T>
+  struct impl
+  {
+      static typename boost::remove_cv<T>::type& x;
+
+      BOOST_STATIC_CONSTANT(
+          bool
+        , value = sizeof(is_dereferenceable_::check_increment(BOOST_comma(*x,0))) == 1
+      );
+  };
+}
+
+# undef BOOST_comma
+
+template<typename T> 
+struct is_dereferenceable 
+    : public ::boost::integral_constant<bool, is_dereferenceable_::impl<T>::value >
+{ 
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_dereferenceable,(T))
+};
+
+} } 
+
+
+} // End namespaces detail, iostreams, boost.
+
+#endif // BOOST_IOSTREAMS_DETAIL_IS_DEREFERENCEABLE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/is_iterator_range.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/is_iterator_range.hpp
new file mode 100644
index 0000000000..39d845f4a3
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/is_iterator_range.hpp
@@ -0,0 +1,34 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_IS_ITERATOR_RANGE_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_IS_ITERATOR_RANGE_HPP_INCLUDED       
+ 
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/detail/bool_trait_def.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>
+
+namespace boost { 
+
+// We avoid dependence on Boost.Range by using a forward declaration.
+template<typename Iterator>
+class iterator_range;
+    
+namespace iostreams {
+
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_iterator_range, boost::iterator_range, 1)
+
+} // End namespace iostreams.
+
+} // End namespace boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp>
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_IS_ITERATOR_RANGE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/optional.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/optional.hpp
new file mode 100644
index 0000000000..867dfbda69
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/optional.hpp
@@ -0,0 +1,114 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2005-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Recent changes to Boost.Optional involving assigment broke Boost.Iostreams,
+// in a way which could be remedied only by relying on the deprecated reset
+// functions; with VC6, even reset didn't work. Until this problem is 
+// understood, Iostreams will use a private version of optional with a smart 
+// pointer interface.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_OPTIONAL_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_OPTIONAL_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/assert.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/type_traits/aligned_storage.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+
+namespace boost { namespace iostreams { namespace detail {
+
+// Taken from <boost/optional.hpp>.
+template<class T>
+class aligned_storage
+{
+    // Borland ICEs if unnamed unions are used for this!
+    union dummy_u
+    {
+        char data[ sizeof(T) ];
+        BOOST_DEDUCED_TYPENAME type_with_alignment<
+          ::boost::alignment_of<T>::value >::type aligner_;
+    } dummy_ ;
+
+  public:
+
+    void const* address() const { return &dummy_.data[0]; }
+    void      * address()       { return &dummy_.data[0]; }
+};
+
+template<typename T>
+class optional {
+public:
+    typedef T element_type;
+    optional() : initialized_(false) { }
+    optional(const T& t) : initialized_(false) { reset(t); }
+    ~optional() { reset(); }
+    T& operator*() 
+    { 
+        BOOST_ASSERT(initialized_);
+        return *static_cast<T*>(address()); 
+    }
+    const T& operator*() const
+    { 
+        BOOST_ASSERT(initialized_);
+        return *static_cast<const T*>(address()); 
+    }
+    T* operator->() 
+    { 
+        BOOST_ASSERT(initialized_);
+        return static_cast<T*>(address()); 
+    }
+    const T* operator->() const
+    { 
+        BOOST_ASSERT(initialized_);
+        return static_cast<const T*>(address()); 
+    }
+    T* get() 
+    { 
+        BOOST_ASSERT(initialized_);
+        return static_cast<T*>(address()); 
+    }
+    const T* get() const
+    { 
+        BOOST_ASSERT(initialized_);
+        return static_cast<const T*>(address()); 
+    }
+    void reset() 
+    {
+        if (initialized_) { 
+        #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) || \
+            BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) \
+            /**/
+            T* t = static_cast<T*>(address());
+            t->~T();
+        #else
+            static_cast<T*>(address())->T::~T();
+        #endif
+            initialized_ = false;
+        }
+    }
+    void reset(const T& t) 
+    {
+        reset();
+        new (address()) T(t); 
+        initialized_ = true;
+    }
+private:
+    optional(const optional&);
+    optional& operator=(const optional&);
+    void* address() { return &storage_; }
+    const void* address() const { return &storage_; }
+    aligned_storage<T>  storage_;
+    bool                initialized_;
+};
+
+} } } // End namespaces detail, iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_OPTIONAL_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/path.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/path.hpp
new file mode 100644
index 0000000000..a5d1ad330f
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/path.hpp
@@ -0,0 +1,214 @@
+/*
+ * 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/iostreams for documentation.
+ *
+ * File:        boost/iostreams/detail/path.hpp
+ * Date:        Sat Jun 21 21:24:05 MDT 2008
+ * Copyright:   2008 CodeRage, LLC
+ * Author:      Jonathan Turkanis
+ * Contact:     turkanis at coderage dot com
+ *
+ * Defines the class boost::iostreams::detail::path, for storing a 
+ * a std::string or std::wstring.
+ *
+ * This class allows interoperability with Boost.Filesystem without
+ * creating a dependence on Boost.Filesystem headers or implementation.
+ */
+
+#ifndef BOOST_IOSTREAMS_DETAIL_PATH_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_PATH_HPP_INCLUDED
+
+#include <cstring>
+#include <string>
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS
+# include <cwchar>
+#endif
+#include <boost/static_assert.hpp>
+#include <boost/type.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace iostreams { namespace detail {
+
+#ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS //------------------------------------//
+
+class path {
+    template<typename T, typename V>
+    struct sfinae
+    {
+        typedef V type;
+    };
+public:
+
+    // Default constructor
+    path() : narrow_(), wide_(), is_wide_(false) { }
+
+    // Constructor taking a std::string
+    path(const std::string& p) : narrow_(p), wide_(), is_wide_(false) { }
+
+    // Constructor taking a C-style string
+    path(const char* p) : narrow_(p), wide_(), is_wide_(false) { }
+
+    // Constructor taking a boost::filesystem2::path or
+    // boost::filesystem2::wpath
+    template<typename Path>
+    explicit path(const Path& p, typename Path::external_string_type* = 0)
+    {
+        init(p.external_file_string());
+    }
+
+    // Constructor taking a boost::filesystem3::path (boost filesystem v3)
+    template<typename Path>
+    explicit path(const Path& p, typename Path::codecvt_type* = 0)
+    {
+        init(p.native());
+    }
+
+    // Copy constructor
+    path(const path& p) 
+        : narrow_(p.narrow_), wide_(p.wide_), is_wide_(p.is_wide_) 
+        { }
+
+    // Assignment operator taking another path
+    path& operator=(const path& p)
+    {
+        narrow_ = p.narrow_;
+        wide_ = p.wide_;
+        is_wide_ = p.is_wide_;
+        return *this;
+    }
+
+    // Assignment operator taking a std::string
+    path& operator=(const std::string& p)
+    {
+        narrow_ = p;
+        wide_.clear();
+        is_wide_ = false;
+        return *this;
+    }
+
+    // Assignment operator taking a C-style string
+    path& operator=(const char* p)
+    {
+        narrow_.assign(p);
+        wide_.clear();
+        is_wide_ = false;
+        return *this;
+    }
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
+    // Assignment operator taking a boost::filesystem2::path or
+    // boost::filesystem2::wpath
+    // (not on Visual C++ 7.1/8.0, as it seems to have problems with
+    // SFINAE functions with the same parameters, doesn't seem
+    // worth working around).
+    template<typename Path>
+    typename sfinae<typename Path::external_string_type, path&>::type
+        operator=(const Path& p)
+    {
+        init(p.external_file_string());
+        return *this;
+    }
+#endif
+
+    // Assignment operator taking a boost::filesystem3::path
+    template<typename Path>
+    typename sfinae<typename Path::codecvt_type, path&>::type
+        operator=(const Path& p)
+    {
+        init(p.native());
+        return *this;
+    }
+
+    bool is_wide() const { return is_wide_; }
+
+    // Returns a representation of the underlying path as a std::string
+    // Requires: is_wide() returns false
+    const char* c_str() const { return narrow_.c_str(); }
+
+    // Returns a representation of the underlying path as a std::wstring
+    // Requires: is_wide() returns true
+    const wchar_t* c_wstr() const { return wide_.c_str(); }
+private:
+    
+    // For wide-character paths, use a boost::filesystem::wpath instead of a
+    // std::wstring
+    path(const std::wstring&);
+    path& operator=(const std::wstring&);
+
+    void init(std::string const& file_path)
+    {
+        narrow_ = file_path;
+        wide_.clear();
+        is_wide_ = false;
+    }
+
+    void init(std::wstring const& file_path)
+    {
+        narrow_.clear();
+        wide_ = file_path;
+        is_wide_ = true;
+    }
+
+    std::string   narrow_;
+    std::wstring  wide_;
+    bool          is_wide_;
+};
+
+inline bool operator==(const path& lhs, const path& rhs)
+{
+    return lhs.is_wide() ?
+        rhs.is_wide() && std::wcscmp(lhs.c_wstr(), rhs.c_wstr()) == 0 :
+        !rhs.is_wide() && std::strcmp(lhs.c_str(), rhs.c_str()) == 0;
+}
+
+#else // #ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS //---------------------------//
+
+class path {
+public:
+    path() { }
+    path(const std::string& p) : path_(p) { }
+    path(const char* p) : path_(p) { }
+    template<typename Path>
+        path(const Path& p) : path_(p.external_file_string()) { }
+    path(const path& p) : path_(p.path_) { }
+    path& operator=(const path& other) 
+    {
+        path_ = other.path_;
+        return *this;
+    }
+    path& operator=(const std::string& p) 
+    {
+        path_ = p;
+        return *this;
+    }
+    path& operator=(const char* p) 
+    {
+        path_ = p;
+        return *this;
+    }
+    template<typename Path>
+        path& operator=(const Path& p)
+        {
+            path_ = p.external_file_string();
+            return *this;
+        }
+    bool is_wide() const { return false; }
+    const char* c_str() const { return path_.c_str(); }
+    const wchar_t* c_wstr() const { return 0; }
+private:
+    std::string path_;
+};
+
+inline bool operator==(const path& lhs, const path& rhs)
+{
+    return std::strcmp(lhs.c_str(), rhs.c_str()) == 0 ;
+}
+
+#endif // #ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS //--------------------------//
+
+} } } // End namespaces detail, iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_PATH_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/push.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/push.hpp
new file mode 100644
index 0000000000..1a9393cb02
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/push.hpp
@@ -0,0 +1,153 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_PUSH_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_PUSH_HPP_INCLUDED 
+
+#if defined(_MSC_VER)
+# pragma once
+#endif                    
+ 
+#include <boost/config.hpp> // BOOST_MSVC.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/categories.hpp>
+#include <boost/iostreams/categories.hpp>
+#include <boost/iostreams/detail/adapter/range_adapter.hpp>
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#include <boost/iostreams/detail/enable_if_stream.hpp>   
+#include <boost/iostreams/pipeline.hpp>   
+#include <boost/iostreams/detail/push_params.hpp>   
+#include <boost/iostreams/detail/resolve.hpp>
+#include <boost/mpl/bool.hpp>   
+#include <boost/preprocessor/cat.hpp> 
+#include <boost/preprocessor/control/iif.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+
+//
+// Macro: BOOST_IOSTREAMS_DEFINE_PUSH_CONSTRUCTOR(name, mode, ch, helper).
+// Description: Defines overloads with name 'name' which forward to a function
+//      'helper' which takes a filter or devide by const reference.
+//
+#define BOOST_IOSTREAMS_DEFINE_PUSH_CONSTRUCTOR(name, mode, ch, helper) \
+    BOOST_IOSTREAMS_DEFINE_PUSH_IMPL(name, mode, ch, helper, 0, ?) \
+    /**/
+
+//
+// Macro: BOOST_IOSTREAMS_DEFINE_PUSH(name, mode, ch, helper).
+// Description: Defines constructors which forward to a function
+//      'helper' which takes a filter or device by const reference.
+//
+#define BOOST_IOSTREAMS_DEFINE_PUSH(name, mode, ch, helper) \
+    BOOST_IOSTREAMS_DEFINE_PUSH_IMPL(name, mode, ch, helper, 1, void) \
+    /**/
+
+//--------------------Definition of BOOST_IOSTREAMS_DEFINE_PUSH_IMPL----------//
+          
+#define BOOST_IOSTREAMS_ADAPT_STREAM(mode, ch, arg, helper, has_return) \
+    this->helper( ::boost::iostreams::detail::resolve<mode, ch>(arg) \
+                  BOOST_IOSTREAMS_PUSH_ARGS() ); \
+    /**/
+
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) \
+    /**/
+# ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
+#  define BOOST_IOSTREAMS_DEFINE_PUSH_IMPL(name, mode, ch, helper, has_return, result) \
+    template<typename CharType, typename TraitsType> \
+    BOOST_PP_IIF(has_return, result, explicit) \
+    name(::std::basic_streambuf<CharType, TraitsType>& sb BOOST_IOSTREAMS_PUSH_PARAMS()) \
+    { BOOST_IOSTREAMS_ADAPT_STREAM(mode, ch, sb, helper, has_return); } \
+    template<typename CharType, typename TraitsType> \
+    BOOST_PP_IIF(has_return, result, explicit) \
+    name(::std::basic_istream<CharType, TraitsType>& is BOOST_IOSTREAMS_PUSH_PARAMS()) \
+    { BOOST_STATIC_ASSERT((!is_convertible<mode, output>::value)); \
+      BOOST_IOSTREAMS_ADAPT_STREAM(mode, ch, is, helper, has_return); } \
+    template<typename CharType, typename TraitsType> \
+    BOOST_PP_IIF(has_return, result, explicit) \
+    name(::std::basic_ostream<CharType, TraitsType>& os BOOST_IOSTREAMS_PUSH_PARAMS()) \
+    { BOOST_STATIC_ASSERT((!is_convertible<mode, input>::value)); \
+      BOOST_IOSTREAMS_ADAPT_STREAM(mode, ch, os, helper, has_return); } \
+    template<typename CharType, typename TraitsType> \
+    BOOST_PP_IIF(has_return, result, explicit) \
+    name(::std::basic_iostream<CharType, TraitsType>& io BOOST_IOSTREAMS_PUSH_PARAMS()) \
+    { BOOST_IOSTREAMS_ADAPT_STREAM(mode, ch, io, helper, has_return); } \
+    template<typename Iter> \
+    BOOST_PP_IIF(has_return, result, explicit) \
+    name(const iterator_range<Iter>& rng BOOST_IOSTREAMS_PUSH_PARAMS()) \
+    { BOOST_PP_EXPR_IF(has_return, return) \
+    this->helper( ::boost::iostreams::detail::range_adapter< \
+                      mode, iterator_range<Iter> \
+                  >(rng) \
+                  BOOST_IOSTREAMS_PUSH_ARGS() ); } \
+    template<typename Pipeline, typename Concept> \
+    BOOST_PP_IIF(has_return, result, explicit) \
+    name(const ::boost::iostreams::pipeline<Pipeline, Concept>& p) \
+    { p.push(*this); } \
+    template<typename T> \
+    BOOST_PP_IIF(has_return, result, explicit) \
+    name(const T& t BOOST_IOSTREAMS_PUSH_PARAMS() BOOST_IOSTREAMS_DISABLE_IF_STREAM(T)) \
+    { this->helper( ::boost::iostreams::detail::resolve<mode, ch>(t) \
+                    BOOST_IOSTREAMS_PUSH_ARGS() ); } \
+    /**/
+# else // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
+#  define BOOST_IOSTREAMS_DEFINE_PUSH_IMPL(name, mode, ch, helper, has_return, result) \
+    BOOST_PP_IF(has_return, result, explicit) \
+    name(::std::streambuf& sb BOOST_IOSTREAMS_PUSH_PARAMS()) \
+    { BOOST_IOSTREAMS_ADAPT_STREAM(mode, ch, sb, helper, has_return); } \
+    BOOST_PP_IF(has_return, result, explicit) \
+    name(::std::istream& is BOOST_IOSTREAMS_PUSH_PARAMS()) \
+    { BOOST_STATIC_ASSERT((!is_convertible<mode, output>::value)); \
+      BOOST_IOSTREAMS_ADAPT_STREAM(mode, ch, is, helper, has_return); } \
+    BOOST_PP_IF(has_return, result, explicit) \
+    name(::std::ostream& os BOOST_IOSTREAMS_PUSH_PARAMS()) \
+    { BOOST_STATIC_ASSERT((!is_convertible<mode, input>::value)); \
+      BOOST_IOSTREAMS_ADAPT_STREAM(mode, ch, os, helper, has_return); } \
+    BOOST_PP_IF(has_return, result, explicit) \
+    name(::std::iostream& io BOOST_IOSTREAMS_PUSH_PARAMS()) \
+    { BOOST_IOSTREAMS_ADAPT_STREAM(mode, ch, io, helper, has_return); } \
+    template<typename Iter> \
+    BOOST_PP_IF(has_return, result, explicit) \
+    name(const iterator_range<Iter>& rng BOOST_IOSTREAMS_PUSH_PARAMS()) \
+    { BOOST_PP_EXPR_IF(has_return, return) \
+    this->helper( ::boost::iostreams::detail::range_adapter< \
+                      mode, iterator_range<Iter> \
+                  >(rng) \
+                  BOOST_IOSTREAMS_PUSH_ARGS() ); } \
+    template<typename Pipeline, typename Concept> \
+    BOOST_PP_IF(has_return, result, explicit) \
+    name(const ::boost::iostreams::pipeline<Pipeline, Concept>& p) \
+    { p.push(*this); } \
+    template<typename T> \
+    BOOST_PP_EXPR_IF(has_return, result) \
+    name(const T& t BOOST_IOSTREAMS_PUSH_PARAMS() BOOST_IOSTREAMS_DISABLE_IF_STREAM(T)) \
+    { this->helper( ::boost::iostreams::detail::resolve<mode, ch>(t) \
+                    BOOST_IOSTREAMS_PUSH_ARGS() ); } \
+    /**/
+# endif // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
+#else // #if VC6, VC7.0, Borland 5.x
+# define BOOST_IOSTREAMS_DEFINE_PUSH_IMPL(name, mode, ch, helper, has_return, result) \
+    template<typename T> \
+    void BOOST_PP_CAT(name, _msvc_impl) \
+    ( ::boost::mpl::true_, const T& t BOOST_IOSTREAMS_PUSH_PARAMS() ) \
+    { t.push(*this); } \
+    template<typename T> \
+    void BOOST_PP_CAT(name, _msvc_impl) \
+    ( ::boost::mpl::false_, const T& t BOOST_IOSTREAMS_PUSH_PARAMS() ) \
+    { this->helper( ::boost::iostreams::detail::resolve<mode, ch>(t) \
+                    BOOST_IOSTREAMS_PUSH_ARGS() ); } \
+    template<typename T> \
+    BOOST_PP_IF(has_return, result, explicit) \
+    name(const T& t BOOST_IOSTREAMS_PUSH_PARAMS()) \
+    { \
+        this->BOOST_PP_CAT(name, _msvc_impl) \
+              ( ::boost::iostreams::detail::is_pipeline<T>(), \
+                t BOOST_IOSTREAMS_PUSH_ARGS() ); \
+    } \
+    /**/
+#endif // #if VC6, VC7.0, Borland 5.x
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_PUSH_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/push_params.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/push_params.hpp
new file mode 100644
index 0000000000..8d8e5d74b3
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/push_params.hpp
@@ -0,0 +1,21 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_PUSH_PARAMS_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_PUSH_PARAMS_HPP_INCLUDED 
+
+#if defined(_MSC_VER)
+# pragma once
+#endif                    
+
+#define BOOST_IOSTREAMS_PUSH_PARAMS() \
+    , std::streamsize buffer_size = -1 , std::streamsize pback_size = -1 \
+    /**/
+
+#define BOOST_IOSTREAMS_PUSH_ARGS() , buffer_size, pback_size     
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_PUSH_PARAMS_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/resolve.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/resolve.hpp
new file mode 100644
index 0000000000..2d480950e1
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/resolve.hpp
@@ -0,0 +1,230 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_RESOLVE_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_RESOLVE_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <boost/config.hpp> // partial spec, put size_t in std.
+#include <cstddef>          // std::size_t.
+#include <boost/detail/is_incrementable.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/detail/adapter/mode_adapter.hpp>
+#include <boost/iostreams/detail/adapter/output_iterator_adapter.hpp>
+#include <boost/iostreams/detail/adapter/range_adapter.hpp>
+#include <boost/iostreams/detail/config/gcc.hpp>
+#include <boost/iostreams/detail/config/overload_resolution.hpp>
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#include <boost/iostreams/detail/enable_if_stream.hpp>
+#include <boost/iostreams/detail/is_dereferenceable.hpp>
+#include <boost/iostreams/detail/is_iterator_range.hpp>
+#include <boost/iostreams/detail/select.hpp>
+#include <boost/iostreams/detail/wrap_unwrap.hpp>
+#include <boost/iostreams/device/array.hpp>
+#include <boost/iostreams/traits.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/bool.hpp> // true_.
+#include <boost/mpl/if.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/type_traits/is_array.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp> // VC7.1 C4224.
+
+namespace boost { namespace iostreams { namespace detail {
+
+//------------------Definition of resolve-------------------------------------//
+
+#ifndef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION //-------------------------//
+
+template<typename Mode, typename Ch, typename T>
+struct resolve_traits {
+    typedef typename 
+            mpl::if_<
+                boost::detail::is_incrementable<T>,
+                output_iterator_adapter<Mode, Ch, T>,
+                const T&
+            >::type type;
+};
+
+# ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //-------------------------------//
+
+template<typename Mode, typename Ch, typename T>
+typename resolve_traits<Mode, Ch, T>::type
+resolve( const T& t 
+         BOOST_IOSTREAMS_DISABLE_IF_STREAM(T)
+
+         // I suspect that the compilers which require this workaround may
+         // be correct, but I'm not sure why :(
+         #if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, BOOST_TESTED_AT(810)) ||\
+             BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205)) || \
+             BOOST_WORKAROUND(BOOST_IOSTREAMS_GCC, BOOST_TESTED_AT(400)) ||\
+             BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(1110))
+             /**/
+         , typename disable_if< is_iterator_range<T> >::type* = 0
+         #endif
+         )
+{
+    typedef typename resolve_traits<Mode, Ch, T>::type return_type;
+    return return_type(t);
+}
+
+template<typename Mode, typename Ch, typename Tr>
+mode_adapter< Mode, std::basic_streambuf<Ch, Tr> > 
+resolve(std::basic_streambuf<Ch, Tr>& sb)
+{ return mode_adapter< Mode, std::basic_streambuf<Ch, Tr> >(wrap(sb)); }
+
+template<typename Mode, typename Ch, typename Tr>
+mode_adapter< Mode, std::basic_istream<Ch, Tr> > 
+resolve(std::basic_istream<Ch, Tr>& is)
+{ return mode_adapter< Mode, std::basic_istream<Ch, Tr> >(wrap(is)); }
+
+template<typename Mode, typename Ch, typename Tr>
+mode_adapter< Mode, std::basic_ostream<Ch, Tr> > 
+resolve(std::basic_ostream<Ch, Tr>& os)
+{ return mode_adapter< Mode, std::basic_ostream<Ch, Tr> >(wrap(os)); }
+
+template<typename Mode, typename Ch, typename Tr>
+mode_adapter< Mode, std::basic_iostream<Ch, Tr> > 
+resolve(std::basic_iostream<Ch, Tr>& io)
+{ return mode_adapter< Mode, std::basic_iostream<Ch, Tr> >(wrap(io)); }
+
+template<typename Mode, typename Ch, std::size_t N>
+array_adapter<Mode, Ch> resolve(Ch (&array)[N])
+{ return array_adapter<Mode, Ch>(array); }
+
+template<typename Mode, typename Ch, typename Iter>
+range_adapter< Mode, boost::iterator_range<Iter> >
+resolve(const boost::iterator_range<Iter>& rng)
+{ return range_adapter< Mode, boost::iterator_range<Iter> >(rng); }
+
+# else // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //---------------------//
+
+template<typename Mode, typename Ch, typename T>
+typename resolve_traits<Mode, Ch, T>::type
+resolve( const T& t 
+         BOOST_IOSTREAMS_DISABLE_IF_STREAM(T)
+         #if defined(__GNUC__)
+         , typename disable_if< is_iterator_range<T> >::type* = 0
+         #endif
+         )
+{
+    typedef typename resolve_traits<Mode, Ch, T>::type return_type;
+    return return_type(t);
+}
+
+template<typename Mode, typename Ch>
+mode_adapter<Mode, std::streambuf> 
+resolve(std::streambuf& sb) 
+{ return mode_adapter<Mode, std::streambuf>(wrap(sb)); }
+
+template<typename Mode, typename Ch>
+mode_adapter<Mode, std::istream> 
+resolve(std::istream& is)
+{ return mode_adapter<Mode, std::istream>(wrap(is)); }
+
+template<typename Mode, typename Ch>
+mode_adapter<Mode, std::ostream> 
+resolve(std::ostream& os)
+{ return mode_adapter<Mode, std::ostream>(wrap(os)); }
+
+template<typename Mode, typename Ch>
+mode_adapter<Mode, std::iostream> 
+resolve(std::iostream& io)
+{ return mode_adapter<Mode, std::iostream>(wrap(io)); }
+
+template<typename Mode, typename Ch, std::size_t N>
+array_adapter<Mode, Ch> resolve(Ch (&array)[N])
+{ return array_adapter<Mode, Ch>(array); }
+
+template<typename Mode, typename Ch, typename Iter>
+range_adapter< Mode, boost::iterator_range<Iter> > 
+resolve(const boost::iterator_range<Iter>& rng)
+{ return range_adapter< Mode, boost::iterator_range<Iter> >(rng); }
+
+# endif // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //--------------------//
+#else // #ifndef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION //----------------//
+
+template<typename Mode, typename Ch, typename T>
+struct resolve_traits {
+    // Note: test for is_iterator_range must come before test for output
+    // iterator.
+    typedef typename 
+            iostreams::select<  // Disambiguation for Tru64.
+                is_std_io<T>,
+                mode_adapter<Mode, T>,
+                is_iterator_range<T>,
+                range_adapter<Mode, T>,
+                is_dereferenceable<T>,
+                output_iterator_adapter<Mode, Ch, T>,
+                is_array<T>,
+                array_adapter<Mode, T>,
+                else_,
+                #if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+                    const T&
+                #else
+                    T
+                #endif
+            >::type type;
+};
+
+template<typename Mode, typename Ch, typename T>
+typename resolve_traits<Mode, Ch, T>::type 
+resolve(const T& t, mpl::true_)
+{   // Bad overload resolution.
+    typedef typename resolve_traits<Mode, Ch, T>::type return_type;
+    return return_type(wrap(const_cast<T&>(t)));
+}
+
+template<typename Mode, typename Ch, typename T>
+typename resolve_traits<Mode, Ch, T>::type 
+resolve(const T& t, mpl::false_)
+{ 
+    typedef typename resolve_traits<Mode, Ch, T>::type return_type;
+    return return_type(t);
+}
+
+template<typename Mode, typename Ch, typename T>
+typename resolve_traits<Mode, Ch, T>::type 
+resolve(const T& t BOOST_IOSTREAMS_DISABLE_IF_STREAM(T))
+{ return resolve<Mode, Ch>(t, is_std_io<T>()); }
+
+# if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && \
+     !defined(__GNUC__) // ---------------------------------------------------//
+
+template<typename Mode, typename Ch, typename T>
+typename resolve_traits<Mode, Ch, T>::type 
+resolve(T& t, mpl::true_)
+{ 
+    typedef typename resolve_traits<Mode, Ch, T>::type return_type;
+    return return_type(wrap(t));
+}
+
+template<typename Mode, typename Ch, typename T>
+typename resolve_traits<Mode, Ch, T>::type 
+resolve(T& t, mpl::false_)
+{ 
+    typedef typename resolve_traits<Mode, Ch, T>::type return_type;
+    return return_type(t);
+}
+
+template<typename Mode, typename Ch, typename T>
+typename resolve_traits<Mode, Ch, T>::type 
+resolve(T& t BOOST_IOSTREAMS_ENABLE_IF_STREAM(T))
+{ return resolve<Mode, Ch>(t, is_std_io<T>()); }
+
+# endif // Borland 5.x or GCC //--------------------------------//
+#endif // #ifndef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION //---------------//
+
+} } } // End namespaces detail, iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp> // VC7.1 4224.
+
+#endif // BOOST_IOSTREAMS_DETAIL_RESOLVE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/select.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/select.hpp
new file mode 100644
index 0000000000..16c5973ad1
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/select.hpp
@@ -0,0 +1,86 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Contains the metafunction select, which mimics the effect of a chain of
+// nested mpl if_'s.
+//
+// -----------------------------------------------------------------------------
+//
+// Usage:
+//      
+// typedef typename select<
+//                      case1,  type1,
+//                      case2,  type2,
+//                      ...
+//                      true_,  typen
+//                  >::type selection;
+//
+// Here case1, case2, ... are models of MPL::IntegralConstant with value type
+// bool, and n <= 12.
+
+#ifndef BOOST_IOSTREAMS_SELECT_HPP_INCLUDED
+#define BOOST_IOSTREAMS_SELECT_HPP_INCLUDED   
+
+#if defined(_MSC_VER)
+# pragma once
+#endif                  
+ 
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/void.hpp>
+
+namespace boost { namespace iostreams { 
+
+typedef mpl::true_ else_;
+
+template< typename Case1 = mpl::true_,
+          typename Type1 = mpl::void_,
+          typename Case2 = mpl::true_,
+          typename Type2 = mpl::void_,
+          typename Case3 = mpl::true_,
+          typename Type3 = mpl::void_,
+          typename Case4 = mpl::true_,
+          typename Type4 = mpl::void_,
+          typename Case5 = mpl::true_,
+          typename Type5 = mpl::void_,
+          typename Case6 = mpl::true_,
+          typename Type6 = mpl::void_,
+          typename Case7 = mpl::true_,
+          typename Type7 = mpl::void_,
+          typename Case8 = mpl::true_,
+          typename Type8 = mpl::void_,
+          typename Case9 = mpl::true_,
+          typename Type9 = mpl::void_,
+          typename Case10 = mpl::true_,
+          typename Type10 = mpl::void_,
+          typename Case11 = mpl::true_,
+          typename Type11 = mpl::void_,
+          typename Case12 = mpl::true_,
+          typename Type12 = mpl::void_ >
+struct select {
+    typedef typename
+            mpl::eval_if<
+                Case1, mpl::identity<Type1>, mpl::eval_if<
+                Case2, mpl::identity<Type2>, mpl::eval_if<
+                Case3, mpl::identity<Type3>, mpl::eval_if<
+                Case4, mpl::identity<Type4>, mpl::eval_if<
+                Case5, mpl::identity<Type5>, mpl::eval_if<
+                Case6, mpl::identity<Type6>, mpl::eval_if<
+                Case7, mpl::identity<Type7>, mpl::eval_if<
+                Case8, mpl::identity<Type8>, mpl::eval_if<
+                Case9, mpl::identity<Type9>, mpl::eval_if<
+                Case10, mpl::identity<Type10>, mpl::eval_if<
+                Case11, mpl::identity<Type11>, mpl::if_<
+                Case12, Type12, mpl::void_ > > > > > > > > > > >
+            >::type type;
+};
+
+} } // End namespaces iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_SELECT_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/select_by_size.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/select_by_size.hpp
new file mode 100644
index 0000000000..e08ca3458b
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/select_by_size.hpp
@@ -0,0 +1,161 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2004-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+//
+// Intended as an alternative to type_traits::yes_type and type_traits::no_type.
+// Provides an arbitrary number of types (case_<0>, case_<1>, ...) for
+// determining the results of overload resultion using 'sizeof', plus a uniform
+// means of using the result. yes_type and no_type are typedefs for case_<1>
+// and case_<0>. A single case with negative argument, case_<-1>, is also 
+// provided, for convenience.
+//
+// This header may be included any number of times, with
+// BOOST_SELECT_BY_SIZE_MAX_CASE defined to be the largest N such that case_<N>
+// is needed for a particular application. It defaults to 20.
+//
+// This header depends only on Boost.Config and Boost.Preprocessor. Dependence
+// on Type Traits or MPL was intentionally avoided, to leave open the 
+// possibility that select_by_size could be used by these libraries.
+//
+// Example usage:
+//
+//    #define BOOST_SELECT_BY_SIZE_MAX_CASE 7   // (Needed when default was 2)
+//    #include <boost/utility/select_by_size.hpp>
+//
+//    using namespace boost::utility;
+//
+//    case_<0> helper(bool);
+//    case_<1> helper(int);
+//    case_<2> helper(unsigned);
+//    case_<3> helper(long);
+//    case_<4> helper(unsigned long);
+//    case_<5> helper(float);
+//    case_<6> helper(double);
+//    case_<7> helper(const char*);
+//
+//    struct test {
+//        static const int value =
+//            select_by_size< sizeof(helper(9876UL)) >::value;
+//        BOOST_STATIC_ASSERT(value == 4);
+//    };
+//
+// For compilers with integral constant expression problems, e.g. Borland 5.x,
+// one can also write
+//
+//    struct test {
+//        BOOST_SELECT_BY_SIZE(int, value, helper(9876UL));
+//    };
+//
+// to define a static integral constant 'value' equal to
+//
+//    select_by_size< sizeof(helper(9876UL)) >::value.
+//
+
+// Include guards surround all contents of this header except for explicit
+// specializations of select_by_size for case_<N> with N > 2.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_SELECT_BY_SIZE_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_SELECT_BY_SIZE_HPP_INCLUDED
+
+// The lowest N for which select_by_size< sizeof(case_<N>) > has not been
+// specialized.
+#define SELECT_BY_SIZE_MAX_SPECIALIZED 20
+
+#include <boost/config.hpp>    // BOOST_STATIC_CONSTANT.
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/iteration/local.hpp>
+
+/* Alternative implementation using max_align. 
+
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
+
+namespace boost { namespace utility {
+
+template<int N>
+struct case_ { char c[(N + 1) * alignment_of<detail::max_align>::value]; };
+
+template<unsigned Size>
+struct select_by_size {
+    BOOST_STATIC_CONSTANT(int, value = 
+        (Size / alignment_of<detail::max_align>::value - 1));
+};
+
+} } // End namespaces utility, boost.
+
+*/              // End alternate implementation.
+
+namespace boost { namespace iostreams { namespace detail {
+
+//--------------Definition of case_-------------------------------------------//
+
+template<int N> struct case_ { char c1; case_<N - 1> c2; };
+template<> struct case_<-1> { char c; };
+typedef case_<true> yes_type;
+typedef case_<false> no_type;
+
+//--------------Declaration of select_by_size---------------------------------//
+
+template<unsigned Size> struct select_by_size;
+
+} } } // End namespaces detail, iostreams, boost.
+
+//--------------Definition of SELECT_BY_SIZE_SPEC-----------------------------//
+
+// Sepecializes select_by_size for sizeof(case<n-1>). The decrement is used
+// here because the preprocessor library doesn't handle negative integers.
+#define SELECT_BY_SIZE_SPEC(n) \
+    namespace boost { namespace iostreams { namespace detail { \
+      static const int BOOST_PP_CAT(sizeof_case_, n) = sizeof(case_<n - 1>); \
+      template<> \
+      struct select_by_size< BOOST_PP_CAT(sizeof_case_, n) > { \
+          struct type { BOOST_STATIC_CONSTANT(int, value = n - 1); }; \
+          BOOST_STATIC_CONSTANT(int, value = type::value); \
+      }; \
+    } } } \
+    /**/
+
+//--------------Default specializations of select_by_size---------------------//
+
+#define BOOST_PP_LOCAL_MACRO(n) SELECT_BY_SIZE_SPEC(n)
+#define BOOST_PP_LOCAL_LIMITS (0, 20)
+#include BOOST_PP_LOCAL_ITERATE()
+#undef BOOST_PP_LOCAL_MACRO
+
+//--------------Definition of SELECT_BY_SIZE----------------------------------//
+
+#define BOOST_SELECT_BY_SIZE(type_, name, expr) \
+    BOOST_STATIC_CONSTANT( \
+        unsigned, \
+        BOOST_PP_CAT(boost_select_by_size_temp_, name) = sizeof(expr) \
+    ); \
+    BOOST_STATIC_CONSTANT( \
+        type_, \
+        name = \
+            ( ::boost::iostreams::detail::select_by_size< \
+                BOOST_PP_CAT(boost_select_by_size_temp_, name) \
+              >::value ) \
+    ) \
+    /**/
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_SELECT_BY_SIZE_HPP_INCLUDED
+
+//----------Specializations of SELECT_BY_SIZE (outside main inclued guards)---//
+
+#if defined(BOOST_SELECT_BY_SIZE_MAX_CASE) && \
+    BOOST_SELECT_BY_SIZE_MAX_CASE > SELECT_BY_SIZE_MAX_SPECIALIZED
+
+#define BOOST_PP_LOCAL_MACRO(n) SELECT_BY_SIZE_SPEC(n)
+#define BOOST_PP_LOCAL_LIMITS \
+    (SELECT_BY_SIZE_MAX_SPECIALIZED, BOOST_SELECT_BY_SIZE_MAX_CASE) \
+    /**/
+#include BOOST_PP_LOCAL_ITERATE()
+#undef BOOST_PP_LOCAL_MACRO
+#undef SELECT_BY_SIZE_MAX_SPECIALIZED
+#define SELECT_BY_SIZE_MAX_SPECIALIZED BOOST_SELECT_BY_SIZE_MAX_CASE
+
+#endif
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/streambuf.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/streambuf.hpp
new file mode 100644
index 0000000000..f2e8081b20
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/streambuf.hpp
@@ -0,0 +1,34 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_STREAMBUF_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_STREAMBUF_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+                 
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
+# include <streambuf>
+#else 
+# include <streambuf.h>
+#endif 
+
+#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
+# define BOOST_IOSTREAMS_BASIC_STREAMBUF(ch, tr) std::basic_streambuf< ch, tr >
+# define BOOST_IOSTREAMS_PUBSYNC pubsync
+# define BOOST_IOSTREAMS_PUBSEEKOFF pubseekoff
+# define BOOST_IOSTREAMS_PUBSEEKPOS pubseekpos
+#else
+# define BOOST_IOSTREAMS_BASIC_STREAMBUF(ch, tr) std::streambuf
+# define BOOST_IOSTREAMS_PUBSYNC sync
+# define BOOST_IOSTREAMS_PUBSEEKOFF seekoff
+# define BOOST_IOSTREAMS_PUBSEEKPOS seekpos
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_STREAMBUF_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/streambuf/chainbuf.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/streambuf/chainbuf.hpp
new file mode 100644
index 0000000000..c3714fe041
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/streambuf/chainbuf.hpp
@@ -0,0 +1,113 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_CHAINBUF_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_CHAINBUF_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif      
+
+#include <boost/config.hpp>                    // BOOST_MSVC, template friends.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/chain.hpp>
+#include <boost/iostreams/detail/access_control.hpp>
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#include <boost/iostreams/detail/streambuf.hpp>
+#include <boost/iostreams/detail/streambuf/linked_streambuf.hpp>
+#include <boost/iostreams/detail/translate_int_type.hpp>
+#include <boost/iostreams/traits.hpp>
+#include <boost/noncopyable.hpp>
+
+namespace boost { namespace iostreams { namespace detail {
+
+//--------------Definition of chainbuf----------------------------------------//
+
+//
+// Template name: chainbuf.
+// Description: Stream buffer which operates by delegating to the first
+//      linked_streambuf in a chain.
+// Template parameters:
+//      Chain - The chain type.
+//
+template<typename Chain, typename Mode, typename Access>
+class chainbuf
+    : public BOOST_IOSTREAMS_BASIC_STREAMBUF(
+                 typename Chain::char_type,
+                 typename Chain::traits_type
+             ),
+      public access_control<typename Chain::client_type, Access>,
+      private noncopyable
+{
+private:
+    typedef access_control<chain_client<Chain>, Access>      client_type;
+public:
+    typedef typename Chain::char_type                        char_type;
+    BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(typename Chain::traits_type)
+protected:
+    typedef linked_streambuf<char_type, traits_type>         delegate_type;
+    chainbuf() { client_type::set_chain(&chain_); }
+    int_type underflow() 
+        { sentry t(this); return translate(delegate().underflow()); }
+    int_type pbackfail(int_type c)
+        { sentry t(this); return translate(delegate().pbackfail(c)); }
+    std::streamsize xsgetn(char_type* s, std::streamsize n)
+        { sentry t(this); return delegate().xsgetn(s, n); }
+    int_type overflow(int_type c)
+        { sentry t(this); return translate(delegate().overflow(c)); }
+    std::streamsize xsputn(const char_type* s, std::streamsize n)
+        { sentry t(this); return delegate().xsputn(s, n); }
+    int sync() { sentry t(this); return delegate().sync(); }
+    pos_type seekoff( off_type off, BOOST_IOS::seekdir way,
+                      BOOST_IOS::openmode which =
+                          BOOST_IOS::in | BOOST_IOS::out )
+        { sentry t(this); return delegate().seekoff(off, way, which); }
+    pos_type seekpos( pos_type sp,
+                      BOOST_IOS::openmode which =
+                          BOOST_IOS::in | BOOST_IOS::out )
+        { sentry t(this); return delegate().seekpos(sp, which); }
+protected:
+    typedef BOOST_IOSTREAMS_BASIC_STREAMBUF(
+                 typename Chain::char_type,
+                 typename Chain::traits_type
+             )                                               base_type;
+private:
+
+    // Translate from std int_type to chain's int_type.
+    typedef BOOST_IOSTREAMS_CHAR_TRAITS(char_type)           std_traits;
+    typedef typename Chain::traits_type                      chain_traits;
+    static typename chain_traits::int_type 
+    translate(typename std_traits::int_type c)
+        { return translate_int_type<std_traits, chain_traits>(c); }
+
+    delegate_type& delegate() 
+        { return static_cast<delegate_type&>(chain_.front()); }
+    void get_pointers()
+        {
+            this->setg(delegate().eback(), delegate().gptr(), delegate().egptr());
+            this->setp(delegate().pbase(), delegate().epptr());
+            this->pbump((int) (delegate().pptr() - delegate().pbase()));
+        }
+    void set_pointers()
+        {
+            delegate().setg(this->eback(), this->gptr(), this->egptr());
+            delegate().setp(this->pbase(), this->epptr());
+            delegate().pbump((int) (this->pptr() - this->pbase()));
+        }
+    struct sentry {
+        sentry(chainbuf<Chain, Mode, Access>* buf) : buf_(buf)
+            { buf_->set_pointers(); }
+        ~sentry() { buf_->get_pointers(); }
+        chainbuf<Chain, Mode, Access>* buf_;
+    };
+    friend struct sentry;
+    Chain chain_;
+};
+
+} } } // End namespaces detail, iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CHAINBUF_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/streambuf/direct_streambuf.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/streambuf/direct_streambuf.hpp
new file mode 100644
index 0000000000..69efe2b128
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/streambuf/direct_streambuf.hpp
@@ -0,0 +1,311 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_DIRECT_STREAMBUF_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_DIRECT_STREAMBUF_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <boost/assert.hpp>
+#include <cstddef>
+#include <typeinfo>
+#include <utility>                                 // pair.
+#include <boost/config.hpp>                        // BOOST_DEDUCED_TYPENAME, 
+#include <boost/iostreams/detail/char_traits.hpp>  // member template friends.
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#include <boost/iostreams/detail/error.hpp>
+#include <boost/iostreams/detail/execute.hpp>
+#include <boost/iostreams/detail/functional.hpp>
+#include <boost/iostreams/detail/ios.hpp>
+#include <boost/iostreams/detail/optional.hpp>
+#include <boost/iostreams/detail/streambuf.hpp>
+#include <boost/iostreams/detail/streambuf/linked_streambuf.hpp>
+#include <boost/iostreams/operations.hpp>
+#include <boost/iostreams/positioning.hpp>
+#include <boost/iostreams/traits.hpp>
+#include <boost/throw_exception.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp> // MSVC.
+
+namespace boost { namespace iostreams { 
+    
+namespace detail {
+
+template< typename T,
+          typename Tr = 
+              BOOST_IOSTREAMS_CHAR_TRAITS(
+                 BOOST_DEDUCED_TYPENAME char_type_of<T>::type 
+              ) >
+class direct_streambuf 
+    : public linked_streambuf<BOOST_DEDUCED_TYPENAME char_type_of<T>::type, Tr>
+{
+public:
+    typedef typename char_type_of<T>::type                char_type;
+    BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr)
+private:
+    typedef linked_streambuf<char_type, traits_type>      base_type;
+    typedef typename category_of<T>::type                 category;
+    typedef BOOST_IOSTREAMS_BASIC_STREAMBUF(
+                char_type, traits_type
+            )                                             streambuf_type;
+public: // stream needs access.
+    void open(const T& t, std::streamsize buffer_size, 
+              std::streamsize pback_size);
+    bool is_open() const;
+    void close();
+    bool auto_close() const { return auto_close_; }
+    void set_auto_close(bool close) { auto_close_ = close; }
+    bool strict_sync() { return true; }
+
+    // Declared in linked_streambuf.
+    T* component() { return storage_.get(); }
+protected:
+    BOOST_IOSTREAMS_USING_PROTECTED_STREAMBUF_MEMBERS(base_type)
+    direct_streambuf();
+
+    //--------------Virtual functions-----------------------------------------//
+
+    // Declared in linked_streambuf.
+    void close_impl(BOOST_IOS::openmode m);
+    const std::type_info& component_type() const { return typeid(T); }
+    void* component_impl() { return component(); } 
+#ifdef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
+    public:
+#endif
+
+    // Declared in basic_streambuf.
+    int_type underflow();
+    int_type pbackfail(int_type c);
+    int_type overflow(int_type c);
+    pos_type seekoff( off_type off, BOOST_IOS::seekdir way,
+                      BOOST_IOS::openmode which );
+    pos_type seekpos(pos_type sp, BOOST_IOS::openmode which);
+private:
+    pos_type seek_impl( stream_offset off, BOOST_IOS::seekdir way,
+                        BOOST_IOS::openmode which );
+    void init_input(any_tag) { }
+    void init_input(input);
+    void init_output(any_tag) { }
+    void init_output(output);
+    void init_get_area();
+    void init_put_area();
+    bool one_head() const;
+    bool two_head() const;
+    optional<T>  storage_;
+    char_type   *ibeg_, *iend_, *obeg_, *oend_;
+    bool         auto_close_;
+};
+                    
+//------------------Implementation of direct_streambuf------------------------//
+
+template<typename T, typename Tr>
+direct_streambuf<T, Tr>::direct_streambuf() 
+    : ibeg_(0), iend_(0), obeg_(0), oend_(0), auto_close_(true) 
+{ this->set_true_eof(true); }
+
+template<typename T, typename Tr>
+void direct_streambuf<T, Tr>::open
+    (const T& t, std::streamsize, std::streamsize)
+{
+    storage_.reset(t);
+    init_input(category());
+    init_output(category());
+    setg(0, 0, 0);
+    setp(0, 0);
+    this->set_needs_close();
+}
+
+template<typename T, typename Tr>
+bool direct_streambuf<T, Tr>::is_open() const 
+{ return ibeg_ != 0 || obeg_ != 0; }
+
+template<typename T, typename Tr>
+void direct_streambuf<T, Tr>::close() 
+{ 
+    base_type* self = this;
+    detail::execute_all( detail::call_member_close(*self, BOOST_IOS::in),
+                         detail::call_member_close(*self, BOOST_IOS::out),
+                         detail::call_reset(storage_) );
+}
+
+template<typename T, typename Tr>
+typename direct_streambuf<T, Tr>::int_type 
+direct_streambuf<T, Tr>::underflow()
+{
+    if (!ibeg_) 
+        boost::throw_exception(cant_read());
+    if (!gptr()) 
+        init_get_area();
+    return gptr() != iend_ ? 
+        traits_type::to_int_type(*gptr()) : 
+        traits_type::eof();
+}
+
+template<typename T, typename Tr>
+typename direct_streambuf<T, Tr>::int_type 
+direct_streambuf<T, Tr>::pbackfail(int_type c)
+{
+    using namespace std;
+    if (!ibeg_) 
+        boost::throw_exception(cant_read());
+    if (gptr() != 0 && gptr() != ibeg_) {
+        gbump(-1);
+        if (!traits_type::eq_int_type(c, traits_type::eof()))
+            *gptr() = traits_type::to_char_type(c);
+        return traits_type::not_eof(c);
+    }
+    boost::throw_exception(bad_putback());
+}
+
+template<typename T, typename Tr>
+typename direct_streambuf<T, Tr>::int_type 
+direct_streambuf<T, Tr>::overflow(int_type c)
+{
+    using namespace std;
+    if (!obeg_)
+        boost::throw_exception(BOOST_IOSTREAMS_FAILURE("no write access"));
+    if (!pptr()) init_put_area();
+    if (!traits_type::eq_int_type(c, traits_type::eof())) {
+        if (pptr() == oend_)
+            boost::throw_exception(
+                BOOST_IOSTREAMS_FAILURE("write area exhausted")
+            );
+        *pptr() = traits_type::to_char_type(c);
+        pbump(1);
+        return c;
+    }
+    return traits_type::not_eof(c);
+}
+
+template<typename T, typename Tr>
+inline typename direct_streambuf<T, Tr>::pos_type
+direct_streambuf<T, Tr>::seekoff
+    (off_type off, BOOST_IOS::seekdir way, BOOST_IOS::openmode which)
+{ return seek_impl(off, way, which); }
+
+template<typename T, typename Tr>
+inline typename direct_streambuf<T, Tr>::pos_type
+direct_streambuf<T, Tr>::seekpos
+    (pos_type sp, BOOST_IOS::openmode which)
+{ 
+    return seek_impl(position_to_offset(sp), BOOST_IOS::beg, which);
+}
+
+template<typename T, typename Tr>
+void direct_streambuf<T, Tr>::close_impl(BOOST_IOS::openmode which)
+{
+    if (which == BOOST_IOS::in && ibeg_ != 0) {
+        setg(0, 0, 0);
+        ibeg_ = iend_ = 0;
+    }
+    if (which == BOOST_IOS::out && obeg_ != 0) {
+        sync();
+        setp(0, 0);
+        obeg_ = oend_ = 0;
+    }
+    boost::iostreams::close(*storage_, which);
+}
+
+template<typename T, typename Tr>
+typename direct_streambuf<T, Tr>::pos_type direct_streambuf<T, Tr>::seek_impl
+    (stream_offset off, BOOST_IOS::seekdir way, BOOST_IOS::openmode which)
+{
+    using namespace std;
+    BOOST_IOS::openmode both = BOOST_IOS::in | BOOST_IOS::out;
+    if (two_head() && (which & both) == both)
+        boost::throw_exception(bad_seek());
+    stream_offset result = -1;
+    bool one = one_head();
+    if (one && (pptr() != 0 || gptr()== 0))
+        init_get_area(); // Switch to input mode, for code reuse.
+    if (one || ((which & BOOST_IOS::in) != 0 && ibeg_ != 0)) {
+        if (!gptr()) setg(ibeg_, ibeg_, iend_);
+        ptrdiff_t next = 0;
+        switch (way) {
+        case BOOST_IOS::beg: next = off; break;
+        case BOOST_IOS::cur: next = (gptr() - ibeg_) + off; break;
+        case BOOST_IOS::end: next = (iend_ - ibeg_) + off; break;
+        default: BOOST_ASSERT(0);
+        }
+        if (next < 0 || next > (iend_ - ibeg_))
+            boost::throw_exception(bad_seek());
+        setg(ibeg_, ibeg_ + next, iend_);
+        result = next;
+    }
+    if (!one && (which & BOOST_IOS::out) != 0 && obeg_ != 0) {
+        if (!pptr()) setp(obeg_, oend_);
+        ptrdiff_t next = 0;
+        switch (way) {
+        case BOOST_IOS::beg: next = off; break;
+        case BOOST_IOS::cur: next = (pptr() - obeg_) + off; break;
+        case BOOST_IOS::end: next = (oend_ - obeg_) + off; break;
+        default: BOOST_ASSERT(0);
+        }
+        if (next < 0 || next > (oend_ - obeg_))
+            boost::throw_exception(bad_seek());
+        pbump(static_cast<int>(next - (pptr() - obeg_)));
+        result = next;
+    }
+    return offset_to_position(result);
+}
+
+template<typename T, typename Tr>
+void direct_streambuf<T, Tr>::init_input(input)
+{
+    std::pair<char_type*, char_type*> p = input_sequence(*storage_);
+    ibeg_ = p.first;
+    iend_ = p.second;
+}
+
+template<typename T, typename Tr>
+void direct_streambuf<T, Tr>::init_output(output)
+{
+    std::pair<char_type*, char_type*> p = output_sequence(*storage_);
+    obeg_ = p.first;
+    oend_ = p.second;
+}
+
+template<typename T, typename Tr>
+void direct_streambuf<T, Tr>::init_get_area()
+{
+    setg(ibeg_, ibeg_, iend_);
+    if (one_head() && pptr()) {
+        gbump(static_cast<int>(pptr() - obeg_));
+        setp(0, 0);
+    }
+}
+
+template<typename T, typename Tr>
+void direct_streambuf<T, Tr>::init_put_area()
+{
+    setp(obeg_, oend_);
+    if (one_head() && gptr()) {
+        pbump(static_cast<int>(gptr() - ibeg_));
+        setg(0, 0, 0);
+    }
+}
+
+template<typename T, typename Tr>
+inline bool direct_streambuf<T, Tr>::one_head() const
+{ return ibeg_ && obeg_ && ibeg_ == obeg_; }
+
+template<typename T, typename Tr>
+inline bool direct_streambuf<T, Tr>::two_head() const
+{ return ibeg_ && obeg_ && ibeg_ != obeg_; }
+
+//----------------------------------------------------------------------------//
+
+} // End namespace detail.
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_DIRECT_STREAMBUF_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/streambuf/indirect_streambuf.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/streambuf/indirect_streambuf.hpp
new file mode 100644
index 0000000000..90e1e11531
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/streambuf/indirect_streambuf.hpp
@@ -0,0 +1,447 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// This material is heavily indebted to the discussion and code samples in
+// A. Langer and K. Kreft, "Standard C++ IOStreams and Locales",
+// Addison-Wesley, 2000, pp. 228-43.
+
+// User "GMSB" provided an optimization for small seeks.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_INDIRECT_STREAMBUF_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_INDIRECT_STREAMBUF_HPP_INCLUDED
+
+#include <algorithm>                             // min, max.
+#include <cassert>
+#include <exception>
+#include <typeinfo>
+#include <boost/config.hpp>                      // Member template friends.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/constants.hpp>
+#include <boost/iostreams/detail/adapter/concept_adapter.hpp>
+#include <boost/iostreams/detail/buffer.hpp>
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#include <boost/iostreams/detail/double_object.hpp> 
+#include <boost/iostreams/detail/execute.hpp>
+#include <boost/iostreams/detail/functional.hpp>
+#include <boost/iostreams/detail/ios.hpp>
+#include <boost/iostreams/detail/optional.hpp>
+#include <boost/iostreams/detail/push.hpp>
+#include <boost/iostreams/detail/streambuf/linked_streambuf.hpp>
+#include <boost/iostreams/operations.hpp>
+#include <boost/iostreams/positioning.hpp>
+#include <boost/iostreams/traits.hpp>
+#include <boost/iostreams/operations.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>  // MSVC, BCC 5.x
+
+namespace boost { namespace iostreams { namespace detail {
+
+//
+// Description: The implementation of basic_streambuf used by chains.
+//
+template<typename T, typename Tr, typename Alloc, typename Mode>
+class indirect_streambuf
+    : public linked_streambuf<BOOST_DEDUCED_TYPENAME char_type_of<T>::type, Tr>
+{
+public:
+    typedef typename char_type_of<T>::type                    char_type;
+    BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr)
+private:
+    typedef typename category_of<T>::type                     category;
+    typedef concept_adapter<T>                                wrapper;
+    typedef detail::basic_buffer<char_type, Alloc>            buffer_type;
+    typedef indirect_streambuf<T, Tr, Alloc, Mode>            my_type;
+    typedef detail::linked_streambuf<char_type, traits_type>  base_type;
+    typedef linked_streambuf<char_type, Tr>                   streambuf_type;
+public:
+    indirect_streambuf();
+
+    void open(const T& t BOOST_IOSTREAMS_PUSH_PARAMS());
+    bool is_open() const;
+    void close();
+    bool auto_close() const;
+    void set_auto_close(bool close);
+    bool strict_sync();
+
+    // Declared in linked_streambuf.
+    T* component() { return &*obj(); }
+protected:
+    BOOST_IOSTREAMS_USING_PROTECTED_STREAMBUF_MEMBERS(base_type)
+
+    //----------virtual functions---------------------------------------------//
+
+#ifndef BOOST_IOSTREAMS_NO_LOCALE
+    void imbue(const std::locale& loc);
+#endif
+#ifdef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
+    public:
+#endif
+    int_type underflow();
+    int_type pbackfail(int_type c);
+    int_type overflow(int_type c);
+    int sync();
+    pos_type seekoff( off_type off, BOOST_IOS::seekdir way,
+                      BOOST_IOS::openmode which );
+    pos_type seekpos(pos_type sp, BOOST_IOS::openmode which);
+
+    // Declared in linked_streambuf.
+    void set_next(streambuf_type* next);
+    void close_impl(BOOST_IOS::openmode m);
+    const std::type_info& component_type() const { return typeid(T); }
+    void* component_impl() { return component(); }
+private:
+
+    //----------Accessor functions--------------------------------------------//
+
+    wrapper& obj() { return *storage_; }
+    streambuf_type* next() const { return next_; }
+    buffer_type& in() { return buffer_.first(); }
+    buffer_type& out() { return buffer_.second(); }
+    bool can_read() const { return is_convertible<Mode, input>::value; }
+    bool can_write() const { return is_convertible<Mode, output>::value; }
+    bool output_buffered() const { return (flags_ & f_output_buffered) != 0; }
+    bool shared_buffer() const { return is_convertible<Mode, seekable>::value || is_convertible<Mode, dual_seekable>::value; }
+    void set_flags(int f) { flags_ = f; }
+
+    //----------State changing functions--------------------------------------//
+
+    virtual void init_get_area();
+    virtual void init_put_area();
+
+    //----------Utility function----------------------------------------------//
+
+    pos_type seek_impl( stream_offset off, BOOST_IOS::seekdir way,
+                        BOOST_IOS::openmode which );
+    void sync_impl();
+
+    enum flag_type {
+        f_open             = 1,
+        f_output_buffered  = f_open << 1,
+        f_auto_close       = f_output_buffered << 1
+    };
+
+    optional<wrapper>           storage_;
+    streambuf_type*             next_;
+    double_object<
+        buffer_type,
+        is_convertible<
+            Mode,
+            two_sequence
+        >
+    >                           buffer_;
+    std::streamsize             pback_size_;
+    int                         flags_;
+};
+
+//--------------Implementation of indirect_streambuf--------------------------//
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+indirect_streambuf<T, Tr, Alloc, Mode>::indirect_streambuf()
+    : next_(0), pback_size_(0), flags_(f_auto_close) { }
+
+//--------------Implementation of open, is_open and close---------------------//
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+void indirect_streambuf<T, Tr, Alloc, Mode>::open
+    (const T& t, std::streamsize buffer_size, std::streamsize pback_size)
+{
+    using namespace std;
+
+    // Normalize buffer sizes.
+    buffer_size =
+        (buffer_size != -1) ?
+        buffer_size :
+        iostreams::optimal_buffer_size(t);
+    pback_size =
+        (pback_size != -1) ?
+        pback_size :
+        default_pback_buffer_size;
+
+    // Construct input buffer.
+    if (can_read()) {
+        pback_size_ = (std::max)(std::streamsize(2), pback_size); // STLPort needs 2.
+        std::streamsize size =
+            pback_size_ +
+            ( buffer_size ? buffer_size: std::streamsize(1) );
+        in().resize(static_cast<int>(size));
+        if (!shared_buffer())
+            init_get_area();
+    }
+
+    // Construct output buffer.
+    if (can_write() && !shared_buffer()) {
+        if (buffer_size != std::streamsize(0))
+            out().resize(static_cast<int>(buffer_size));
+        init_put_area();
+    }
+
+    storage_.reset(wrapper(t));
+    flags_ |= f_open;
+    if (can_write() && buffer_size > 1)
+        flags_ |= f_output_buffered;
+    this->set_true_eof(false);
+    this->set_needs_close();
+}
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+inline bool indirect_streambuf<T, Tr, Alloc, Mode>::is_open() const
+{ return (flags_ & f_open) != 0; }
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+void indirect_streambuf<T, Tr, Alloc, Mode>::close()
+{
+    using namespace std;
+    base_type* self = this;
+    detail::execute_all(
+        detail::call_member_close(*self, BOOST_IOS::in),
+        detail::call_member_close(*self, BOOST_IOS::out),
+        detail::call_reset(storage_),
+        detail::clear_flags(flags_)
+    );
+}
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+bool indirect_streambuf<T, Tr, Alloc, Mode>::auto_close() const
+{ return (flags_ & f_auto_close) != 0; }
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+void indirect_streambuf<T, Tr, Alloc, Mode>::set_auto_close(bool close)
+{ flags_ = (flags_ & ~f_auto_close) | (close ? f_auto_close : 0); }
+
+//--------------Implementation virtual functions------------------------------//
+
+#ifndef BOOST_IOSTREAMS_NO_LOCALE
+template<typename T, typename Tr, typename Alloc, typename Mode>
+void indirect_streambuf<T, Tr, Alloc, Mode>::imbue(const std::locale& loc)
+{
+    if (is_open()) {
+        obj().imbue(loc);
+        if (next_)
+            next_->pubimbue(loc);
+    }
+}
+#endif
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+typename indirect_streambuf<T, Tr, Alloc, Mode>::int_type
+indirect_streambuf<T, Tr, Alloc, Mode>::underflow()
+{
+    using namespace std;
+    if (!gptr()) init_get_area();
+    buffer_type& buf = in();
+    if (gptr() < egptr()) return traits_type::to_int_type(*gptr());
+
+    // Fill putback buffer.
+    std::streamsize keep = 
+        (std::min)( static_cast<std::streamsize>(gptr() - eback()),
+                    pback_size_ );
+    if (keep)
+        traits_type::move( buf.data() + (pback_size_ - keep),
+                           gptr() - keep, keep );
+
+    // Set pointers to reasonable values in case read throws.
+    setg( buf.data() + pback_size_ - keep,
+          buf.data() + pback_size_,
+          buf.data() + pback_size_ );
+
+    // Read from source.
+    std::streamsize chars =
+        obj().read(buf.data() + pback_size_, buf.size() - pback_size_, next_);
+    if (chars == -1) {
+        this->set_true_eof(true);
+        chars = 0;
+    }
+    setg(eback(), gptr(), buf.data() + pback_size_ + chars);
+    return chars != 0 ?
+        traits_type::to_int_type(*gptr()) :
+        traits_type::eof();
+}
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+typename indirect_streambuf<T, Tr, Alloc, Mode>::int_type
+indirect_streambuf<T, Tr, Alloc, Mode>::pbackfail(int_type c)
+{
+    if (gptr() != eback()) {
+        gbump(-1);
+        if (!traits_type::eq_int_type(c, traits_type::eof()))
+            *gptr() = traits_type::to_char_type(c);
+        return traits_type::not_eof(c);
+    } else {
+        boost::throw_exception(bad_putback());
+    }
+}
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+typename indirect_streambuf<T, Tr, Alloc, Mode>::int_type
+indirect_streambuf<T, Tr, Alloc, Mode>::overflow(int_type c)
+{
+    if ( (output_buffered() && pptr() == 0) ||
+         (shared_buffer() && gptr() != 0) )
+    {
+        init_put_area();
+    }
+    if (!traits_type::eq_int_type(c, traits_type::eof())) {
+        if (output_buffered()) {
+            if (pptr() == epptr()) {
+                sync_impl();
+                if (pptr() == epptr())
+                    return traits_type::eof();
+            }
+            *pptr() = traits_type::to_char_type(c);
+            pbump(1);
+        } else {
+            char_type d = traits_type::to_char_type(c);
+            if (obj().write(&d, 1, next_) != 1)
+                return traits_type::eof();
+        }
+    }
+    return traits_type::not_eof(c);
+}
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+int indirect_streambuf<T, Tr, Alloc, Mode>::sync()
+{
+    try { // sync() is no-throw.
+        sync_impl();
+        obj().flush(next_);
+        return 0;
+    } catch (...) { return -1; }
+}
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+bool indirect_streambuf<T, Tr, Alloc, Mode>::strict_sync()
+{
+    try { // sync() is no-throw.
+        sync_impl();
+        return obj().flush(next_);
+    } catch (...) { return false; }
+}
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+inline typename indirect_streambuf<T, Tr, Alloc, Mode>::pos_type
+indirect_streambuf<T, Tr, Alloc, Mode>::seekoff
+    (off_type off, BOOST_IOS::seekdir way, BOOST_IOS::openmode which)
+{ return seek_impl(off, way, which); }
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+inline typename indirect_streambuf<T, Tr, Alloc, Mode>::pos_type
+indirect_streambuf<T, Tr, Alloc, Mode>::seekpos
+    (pos_type sp, BOOST_IOS::openmode which)
+{ 
+    return seek_impl(position_to_offset(sp), BOOST_IOS::beg, which); 
+}
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+typename indirect_streambuf<T, Tr, Alloc, Mode>::pos_type
+indirect_streambuf<T, Tr, Alloc, Mode>::seek_impl
+    (stream_offset off, BOOST_IOS::seekdir way, BOOST_IOS::openmode which)
+{
+    if ( gptr() != 0 && way == BOOST_IOS::cur && which == BOOST_IOS::in && 
+         eback() - gptr() <= off && off <= egptr() - gptr() ) 
+    {   // Small seek optimization
+        gbump(static_cast<int>(off));
+        return obj().seek(stream_offset(0), BOOST_IOS::cur, BOOST_IOS::in, next_) -
+               static_cast<off_type>(egptr() - gptr());
+    }
+    if (pptr() != 0) 
+        this->BOOST_IOSTREAMS_PUBSYNC(); // sync() confuses VisualAge 6.
+    if (way == BOOST_IOS::cur && gptr())
+        off -= static_cast<off_type>(egptr() - gptr());
+    bool two_head = is_convertible<category, dual_seekable>::value ||
+                    is_convertible<category, bidirectional_seekable>::value;
+    if (two_head) {
+        BOOST_IOS::openmode both = BOOST_IOS::in | BOOST_IOS::out;
+        if ((which & both) == both)
+            boost::throw_exception(bad_seek());
+        if (which & BOOST_IOS::in) {
+            setg(0, 0, 0);
+        }
+        if (which & BOOST_IOS::out) {
+            setp(0, 0);
+        }
+    }
+    else {
+        setg(0, 0, 0);
+        setp(0, 0);
+    }
+    return obj().seek(off, way, which, next_);
+}
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+inline void indirect_streambuf<T, Tr, Alloc, Mode>::set_next
+    (streambuf_type* next)
+{ next_ = next; }
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+inline void indirect_streambuf<T, Tr, Alloc, Mode>::close_impl
+    (BOOST_IOS::openmode which)
+{
+    if (which == BOOST_IOS::in && is_convertible<Mode, input>::value) {
+        setg(0, 0, 0);
+    }
+    if (which == BOOST_IOS::out && is_convertible<Mode, output>::value) {
+        sync();
+        setp(0, 0);
+    }
+    if ( !is_convertible<category, dual_use>::value ||
+         is_convertible<Mode, input>::value == (which == BOOST_IOS::in) )
+    {
+        obj().close(which, next_);
+    }
+}
+
+//----------State changing functions------------------------------------------//
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+void indirect_streambuf<T, Tr, Alloc, Mode>::sync_impl()
+{
+    std::streamsize avail, amt;
+    if ((avail = static_cast<std::streamsize>(pptr() - pbase())) > 0) {
+        if ((amt = obj().write(pbase(), avail, next())) == avail)
+            setp(out().begin(), out().end());
+        else {
+            const char_type* ptr = pptr();
+            setp(out().begin() + amt, out().end());
+            pbump(static_cast<int>(ptr - pptr()));
+        }
+    }
+}
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+void indirect_streambuf<T, Tr, Alloc, Mode>::init_get_area()
+{
+    if (shared_buffer() && pptr() != 0) {
+        sync_impl();
+        setp(0, 0);
+    }
+    setg(in().begin(), in().begin(), in().begin());
+}
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+void indirect_streambuf<T, Tr, Alloc, Mode>::init_put_area()
+{
+    using namespace std;
+    if (shared_buffer() && gptr() != 0) {
+        obj().seek(static_cast<off_type>(gptr() - egptr()), BOOST_IOS::cur, BOOST_IOS::in, next_);
+        setg(0, 0, 0);
+    }
+    if (output_buffered())
+        setp(out().begin(), out().end());
+    else
+        setp(0, 0);
+}
+
+//----------------------------------------------------------------------------//
+
+} } } // End namespaces detail, iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC, BCC 5.x
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_INDIRECT_STREAMBUF_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/streambuf/linked_streambuf.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/streambuf/linked_streambuf.hpp
new file mode 100644
index 0000000000..9999ded62f
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/streambuf/linked_streambuf.hpp
@@ -0,0 +1,114 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_LINKED_STREAMBUF_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_LINKED_STREAMBUF_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <typeinfo>
+#include <boost/config.hpp>                        // member template friends.
+#include <boost/iostreams/detail/char_traits.hpp>
+#include <boost/iostreams/detail/ios.hpp>          // openmode.
+#include <boost/iostreams/detail/streambuf.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp> // MSVC.
+
+namespace boost { namespace iostreams { namespace detail {
+
+template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
+class chain_base;
+
+template<typename Chain, typename Access, typename Mode> class chainbuf;
+
+#define BOOST_IOSTREAMS_USING_PROTECTED_STREAMBUF_MEMBERS(base) \
+    using base::eback; using base::gptr; using base::egptr; \
+    using base::setg; using base::gbump; using base::pbase; \
+    using base::pptr; using base::epptr; using base::setp; \
+    using base::pbump; using base::underflow; using base::pbackfail; \
+    using base::xsgetn; using base::overflow; using base::xsputn; \
+    using base::sync; using base::seekoff; using base::seekpos; \
+    /**/
+
+template<typename Ch, typename Tr = BOOST_IOSTREAMS_CHAR_TRAITS(Ch) >
+class linked_streambuf : public BOOST_IOSTREAMS_BASIC_STREAMBUF(Ch, Tr) {
+protected:
+    linked_streambuf() : flags_(0) { }
+    void set_true_eof(bool eof) 
+    { 
+        flags_ = (flags_ & ~f_true_eof) | (eof ? f_true_eof : 0); 
+    }
+public:
+
+    // Should be called only after receiving an ordinary EOF indication,
+    // to confirm that it represents EOF rather than WOULD_BLOCK.
+    bool true_eof() const { return (flags_ & f_true_eof) != 0; }
+protected:
+
+    //----------grant friendship to chain_base and chainbuf-------------------//
+
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+    template< typename Self, typename ChT, typename TrT,
+              typename Alloc, typename Mode >
+    friend class chain_base;
+    template<typename Chain, typename Mode, typename Access>
+    friend class chainbuf;
+    template<typename U>
+    friend class member_close_operation; 
+#else
+    public:
+        typedef BOOST_IOSTREAMS_BASIC_STREAMBUF(Ch, Tr) base;
+        BOOST_IOSTREAMS_USING_PROTECTED_STREAMBUF_MEMBERS(base)
+#endif
+    void close(BOOST_IOS::openmode which)
+    {
+        if ( which == BOOST_IOS::in && 
+            (flags_ & f_input_closed) == 0 )
+        {
+            flags_ |= f_input_closed;
+            close_impl(which);
+        }
+        if ( which == BOOST_IOS::out && 
+            (flags_ & f_output_closed) == 0 )
+        {
+            flags_ |= f_output_closed;
+            close_impl(which);
+        }
+    }
+    void set_needs_close()
+    {
+        flags_ &= ~(f_input_closed | f_output_closed);
+    }
+    virtual void set_next(linked_streambuf<Ch, Tr>* /* next */) { }
+    virtual void close_impl(BOOST_IOS::openmode) = 0;
+    virtual bool auto_close() const = 0;
+    virtual void set_auto_close(bool) = 0;
+    virtual bool strict_sync() = 0;
+    virtual const std::type_info& component_type() const = 0;
+    virtual void* component_impl() = 0;
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+    private:
+#else
+    public:
+#endif
+private:
+    enum flag_type {
+        f_true_eof       = 1,
+        f_input_closed   = f_true_eof << 1,
+        f_output_closed  = f_input_closed << 1
+    };
+    int flags_;
+};
+
+} } } // End namespaces detail, iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_LINKED_STREAMBUF_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/system_failure.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/system_failure.hpp
new file mode 100644
index 0000000000..bddcef12b8
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/system_failure.hpp
@@ -0,0 +1,86 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2005-2007 Jonathan Turkanis
+// (C) Copyright Jonathan Graehl 2004.
+// 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/iostreams for documentation.
+
+// Used by mapped_file.cpp.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_SYSTEM_FAILURE_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_SYSTEM_FAILURE_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <cstring>
+#include <string>
+#include <boost/config.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/iostreams/detail/config/windows_posix.hpp>
+#include <boost/iostreams/detail/ios.hpp>  // failure.
+
+#if defined(BOOST_NO_STDC_NAMESPACE) && !defined(__LIBCOMO__)
+namespace std { using ::strlen; }
+#endif
+
+#ifdef BOOST_IOSTREAMS_WINDOWS
+# ifndef WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN  // Exclude rarely-used stuff from Windows headers
+# endif
+# include <windows.h>
+#else
+# include <errno.h>
+# include <string.h>
+#endif
+
+namespace boost { namespace iostreams { namespace detail {
+
+inline BOOST_IOSTREAMS_FAILURE system_failure(const char* msg)
+{
+    std::string result;
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    DWORD err;
+    LPVOID lpMsgBuf;
+    if ( (err = ::GetLastError()) != NO_ERROR &&
+         ::FormatMessageA( FORMAT_MESSAGE_ALLOCATE_BUFFER |
+                           FORMAT_MESSAGE_FROM_SYSTEM,
+                           NULL,
+                           err,
+                           MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                           (LPSTR) &lpMsgBuf,
+                           0,
+                           NULL ) != 0 )
+    {
+        result.reserve(std::strlen(msg) + 2 + std::strlen((LPSTR)lpMsgBuf));
+        result.append(msg);
+        result.append(": ");
+        result.append((LPSTR) lpMsgBuf);
+        ::LocalFree(lpMsgBuf);
+    } else {
+        result += msg;
+    }
+#else
+    const char* system_msg = errno ? strerror(errno) : "";
+    result.reserve(std::strlen(msg) + 2 + std::strlen(system_msg));
+    result.append(msg);
+    result.append(": ");
+    result.append(system_msg);
+#endif
+    return BOOST_IOSTREAMS_FAILURE(result);
+}
+
+inline BOOST_IOSTREAMS_FAILURE system_failure(const std::string& msg)
+{ return system_failure(msg.c_str()); }
+
+inline void throw_system_failure(const char* msg)
+{ boost::throw_exception(system_failure(msg)); }
+
+inline void throw_system_failure(const std::string& msg)
+{ boost::throw_exception(system_failure(msg)); }
+
+} } } // End namespaces detail, iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_SYSTEM_FAILURE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/template_params.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/template_params.hpp
new file mode 100644
index 0000000000..b07012fb82
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/template_params.hpp
@@ -0,0 +1,26 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_TEMPLATE_PARAMS_HPP_INCLUDED
+
+#include <boost/preprocessor/control/expr_if.hpp>
+#include <boost/preprocessor/control/if.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+
+#define BOOST_IOSTREAMS_TEMPLATE_PARAMS(arity, param) \
+    BOOST_PP_EXPR_IF(arity, template<) \
+    BOOST_PP_ENUM_PARAMS(arity, typename param) \
+    BOOST_PP_EXPR_IF(arity, >) \
+    /**/
+
+#define BOOST_IOSTREAMS_TEMPLATE_ARGS(arity, param) \
+    BOOST_PP_EXPR_IF(arity, <) \
+    BOOST_PP_ENUM_PARAMS(arity, param) \
+    BOOST_PP_EXPR_IF(arity, >) \
+    /**/
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_BUFFERS_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/translate_int_type.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/translate_int_type.hpp
new file mode 100644
index 0000000000..ae48a2c46f
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/translate_int_type.hpp
@@ -0,0 +1,62 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_TRANSLATE_INT_TYPE_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_TRANSLATE_INT_TYPE_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace iostreams { namespace detail {
+
+template<bool IsSame>
+struct translate_int_type_impl;
+
+//
+// Template name: translate_char.
+// Description: Translates a character or an end-of-file indicator from the 
+//      int_type of one character traits type to the int_type of another.
+//
+template<typename SourceTr, typename TargetTr>
+typename TargetTr::int_type 
+translate_int_type(typename SourceTr::int_type c) 
+{ 
+    typedef translate_int_type_impl<is_same<SourceTr, TargetTr>::value> impl;
+    return impl::template inner<SourceTr, TargetTr>::translate(c);
+}
+
+//----------------------------------------------------------------------------//
+
+template<>
+struct translate_int_type_impl<true> {
+    template<typename SourceTr, typename TargetTr>
+    struct inner {
+        static typename TargetTr::int_type 
+        translate(typename SourceTr::int_type c) { return c; }
+    };
+};
+
+template<>
+struct translate_int_type_impl<false> {
+    template<typename SourceTr, typename TargetTr>
+    struct inner {
+        static typename TargetTr::int_type 
+        translate(typename SourceTr::int_type c)
+            { 
+                return SourceTr::eq_int_type(SourceTr::eof()) ?
+                           TargetTr::eof() :
+                           TargetTr::to_int_type(SourceTr::to_char_type(c));
+            }
+    };
+};
+
+} } } // End namespaces detail, iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_TRANSLATE_INT_TYPE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/wrap_unwrap.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/wrap_unwrap.hpp
new file mode 100644
index 0000000000..f5f97897f9
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/detail/wrap_unwrap.hpp
@@ -0,0 +1,98 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_DETAIL_WRAP_UNWRAP_HPP_INCLUDED
+#define BOOST_IOSTREAMS_DETAIL_WRAP_UNWRAP_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <boost/config.hpp>                             // SFINAE, MSVC.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/detail/enable_if_stream.hpp>
+#include <boost/iostreams/traits_fwd.hpp>               // is_std_io.
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/ref.hpp>
+
+namespace boost { namespace iostreams { namespace detail {
+                    
+//------------------Definition of wrap/unwrap traits--------------------------//
+
+template<typename T>
+struct wrapped_type 
+    : mpl::if_<is_std_io<T>, reference_wrapper<T>, T>
+    { };
+
+template<typename T>
+struct unwrapped_type 
+    : unwrap_reference<T>
+    { };
+
+template<typename T>
+struct unwrap_ios 
+    : mpl::eval_if<
+          is_std_io<T>, 
+          unwrap_reference<T>, 
+          mpl::identity<T>
+      >
+    { };
+
+//------------------Definition of wrap----------------------------------------//
+
+#ifndef BOOST_NO_SFINAE //----------------------------------------------------//
+    template<typename T>
+    inline T wrap(const T& t BOOST_IOSTREAMS_DISABLE_IF_STREAM(T)) 
+    { return t; }
+
+    template<typename T>
+    inline typename wrapped_type<T>::type
+    wrap(T& t BOOST_IOSTREAMS_ENABLE_IF_STREAM(T)) { return boost::ref(t); }
+#else // #ifndef BOOST_NO_SFINAE //-------------------------------------------//
+    template<typename T>
+    inline typename wrapped_type<T>::type // BCC 5.x needs namespace qualification.
+    wrap_impl(const T& t, mpl::true_) { return boost::ref(const_cast<T&>(t)); }
+
+    template<typename T>
+    inline typename wrapped_type<T>::type // BCC 5.x needs namespace qualification.
+    wrap_impl(T& t, mpl::true_) { return boost::ref(t); }
+
+    template<typename T>
+    inline typename wrapped_type<T>::type 
+    wrap_impl(const T& t, mpl::false_) { return t; }
+
+    template<typename T>
+    inline typename wrapped_type<T>::type 
+    wrap_impl(T& t, mpl::false_) { return t; }
+
+    template<typename T>
+    inline typename wrapped_type<T>::type 
+    wrap(const T& t) { return wrap_impl(t, is_std_io<T>()); }
+
+    template<typename T>
+    inline typename wrapped_type<T>::type 
+    wrap(T& t) { return wrap_impl(t, is_std_io<T>()); }
+#endif // #ifndef BOOST_NO_SFINAE //------------------------------------------//
+
+//------------------Definition of unwrap--------------------------------------//
+
+template<typename T>
+typename unwrapped_type<T>::type& 
+unwrap(const reference_wrapper<T>& ref) { return ref.get(); }
+
+template<typename T>
+typename unwrapped_type<T>::type& unwrap(T& t) { return t; }
+
+template<typename T>
+const typename unwrapped_type<T>::type& unwrap(const T& t) { return t; }
+
+} } } // End namespaces detail, iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_DETAIL_WRAP_UNWRAP_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/device/array.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/device/array.hpp
new file mode 100644
index 0000000000..768a5644a1
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/device/array.hpp
@@ -0,0 +1,133 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2004-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_ARRAY_HPP_INCLUDED
+#define BOOST_IOSTREAMS_ARRAY_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp>         // BOOST_MSVC, make sure size_t is in std.
+#include <boost/detail/workaround.hpp>
+#include <cstddef>                  // std::size_t.
+#include <utility>                  // pair.
+#include <boost/iostreams/categories.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace iostreams {
+
+namespace detail {
+
+template<typename Mode, typename Ch>
+class array_adapter {
+public:
+    typedef Ch                                 char_type;
+    typedef std::pair<char_type*, char_type*>  pair_type;
+    struct category
+        : public Mode,
+          public device_tag,
+          public direct_tag
+        { };
+    array_adapter(char_type* begin, char_type* end);
+    array_adapter(char_type* begin, std::size_t length);
+    array_adapter(const char_type* begin, const char_type* end);
+    array_adapter(const char_type* begin, std::size_t length);
+    template<int N>
+    array_adapter(char_type (&ar)[N])
+        : begin_(ar), end_(ar + N) 
+        { }
+    pair_type input_sequence();
+    pair_type output_sequence();
+private:
+    char_type* begin_;
+    char_type* end_;
+};
+
+} // End namespace detail.
+
+#define BOOST_IOSTREAMS_ARRAY(name, mode) \
+    template<typename Ch> \
+    struct BOOST_PP_CAT(basic_, name) : detail::array_adapter<mode, Ch> { \
+    private: \
+        typedef detail::array_adapter<mode, Ch>  base_type; \
+    public: \
+        typedef typename base_type::char_type    char_type; \
+        typedef typename base_type::category     category; \
+        BOOST_PP_CAT(basic_, name)(char_type* begin, char_type* end) \
+            : base_type(begin, end) { } \
+        BOOST_PP_CAT(basic_, name)(char_type* begin, std::size_t length) \
+            : base_type(begin, length) { } \
+        BOOST_PP_CAT(basic_, name)(const char_type* begin, const char_type* end) \
+            : base_type(begin, end) { } \
+        BOOST_PP_CAT(basic_, name)(const char_type* begin, std::size_t length) \
+            : base_type(begin, length) { } \
+        template<int N> \
+        BOOST_PP_CAT(basic_, name)(Ch (&ar)[N]) \
+            : base_type(ar) { } \
+    }; \
+    typedef BOOST_PP_CAT(basic_, name)<char>     name; \
+    typedef BOOST_PP_CAT(basic_, name)<wchar_t>  BOOST_PP_CAT(w, name); \
+    /**/
+BOOST_IOSTREAMS_ARRAY(array_source, input_seekable)
+BOOST_IOSTREAMS_ARRAY(array_sink, output_seekable)
+BOOST_IOSTREAMS_ARRAY(array, seekable)
+#undef BOOST_IOSTREAMS_ARRAY
+
+
+//------------------Implementation of array_adapter---------------------------//
+
+namespace detail {
+
+template<typename Mode, typename Ch>
+array_adapter<Mode, Ch>::array_adapter
+    (char_type* begin, char_type* end) 
+    : begin_(begin), end_(end) 
+    { }
+
+template<typename Mode, typename Ch>
+array_adapter<Mode, Ch>::array_adapter
+    (char_type* begin, std::size_t length) 
+    : begin_(begin), end_(begin + length) 
+    { }
+
+template<typename Mode, typename Ch>
+array_adapter<Mode, Ch>::array_adapter
+    (const char_type* begin, const char_type* end) 
+    : begin_(const_cast<char_type*>(begin)),  // Treated as read-only.
+      end_(const_cast<char_type*>(end))       // Treated as read-only.
+{ BOOST_STATIC_ASSERT((!is_convertible<Mode, output>::value)); }
+
+template<typename Mode, typename Ch>
+array_adapter<Mode, Ch>::array_adapter
+    (const char_type* begin, std::size_t length) 
+    : begin_(const_cast<char_type*>(begin)),       // Treated as read-only.
+      end_(const_cast<char_type*>(begin) + length) // Treated as read-only.
+{ BOOST_STATIC_ASSERT((!is_convertible<Mode, output>::value)); }
+
+template<typename Mode, typename Ch>
+typename array_adapter<Mode, Ch>::pair_type
+array_adapter<Mode, Ch>::input_sequence()
+{ BOOST_STATIC_ASSERT((is_convertible<Mode, input>::value));
+  return pair_type(begin_, end_); }
+
+template<typename Mode, typename Ch>
+typename array_adapter<Mode, Ch>::pair_type
+array_adapter<Mode, Ch>::output_sequence()
+{ BOOST_STATIC_ASSERT((is_convertible<Mode, output>::value));
+  return pair_type(begin_, end_); }
+
+} // End namespace detail.
+
+//----------------------------------------------------------------------------//
+
+} } // End namespaces iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_ARRAY_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/device/back_inserter.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/device/back_inserter.hpp
new file mode 100644
index 0000000000..669c889e0a
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/device/back_inserter.hpp
@@ -0,0 +1,41 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_BACK_INSERTER_HPP_INCLUDED
+#define BOOST_IOSTREAMS_BACK_INSERTER_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/iostreams/detail/ios.hpp> // streamsize.
+#include <boost/iostreams/categories.hpp>
+
+namespace boost { namespace iostreams {
+
+template<typename Container>
+class back_insert_device {
+public:
+    typedef typename Container::value_type  char_type;
+    typedef sink_tag                        category;
+    back_insert_device(Container& cnt) : container(&cnt) { }
+    std::streamsize write(const char_type* s, std::streamsize n)
+    { 
+        container->insert(container->end(), s, s + n); 
+        return n;
+    }
+protected:
+    Container* container;
+};
+
+template<typename Container>
+back_insert_device<Container> back_inserter(Container& cnt)
+{ return back_insert_device<Container>(cnt); }
+
+} } // End namespaces iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_BACK_INSERTER_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/device/file.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/device/file.hpp
new file mode 100644
index 0000000000..3eb0301647
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/device/file.hpp
@@ -0,0 +1,191 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_FILE_HPP_INCLUDED
+#define BOOST_IOSTREAMS_FILE_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#ifndef BOOST_IOSTREAMS_NO_LOCALE
+# include <locale>
+#endif
+#include <string>                               // pathnames, char_traits.
+#include <boost/iostreams/categories.hpp>
+#include <boost/iostreams/detail/ios.hpp>       // openmode, seekdir, int types.
+#include <boost/iostreams/detail/fstream.hpp>
+#include <boost/iostreams/operations.hpp>       // seek.
+#include <boost/shared_ptr.hpp>      
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>  // MSVC.
+
+namespace boost { namespace iostreams {
+
+template<typename Ch>
+class basic_file {
+public:
+    typedef Ch char_type;
+    struct category
+        : public seekable_device_tag,
+          public closable_tag,
+          public localizable_tag,
+          public flushable_tag
+        { };
+    basic_file( const std::string& path,
+                BOOST_IOS::openmode mode =
+                    BOOST_IOS::in | BOOST_IOS::out,
+                BOOST_IOS::openmode base_mode =
+                    BOOST_IOS::in | BOOST_IOS::out );
+    std::streamsize read(char_type* s, std::streamsize n);
+    bool putback(char_type c);
+    std::streamsize write(const char_type* s, std::streamsize n);
+    std::streampos seek( stream_offset off, BOOST_IOS::seekdir way, 
+                         BOOST_IOS::openmode which = 
+                             BOOST_IOS::in | BOOST_IOS::out );
+    void open( const std::string& path,
+               BOOST_IOS::openmode mode =
+                   BOOST_IOS::in | BOOST_IOS::out,
+               BOOST_IOS::openmode base_mode =
+                   BOOST_IOS::in | BOOST_IOS::out );
+    bool is_open() const;
+    void close();
+    bool flush();
+#ifndef BOOST_IOSTREAMS_NO_LOCALE
+    void imbue(const std::locale& loc) { pimpl_->file_.pubimbue(loc);  }
+#endif
+private:
+    struct impl {
+        impl(const std::string& path, BOOST_IOS::openmode mode)
+            { file_.open(path.c_str(), mode); }
+        ~impl() { if (file_.is_open()) file_.close(); }
+        BOOST_IOSTREAMS_BASIC_FILEBUF(Ch) file_;
+    };
+    shared_ptr<impl> pimpl_;
+};
+
+typedef basic_file<char>     file;
+typedef basic_file<wchar_t>  wfile;
+
+template<typename Ch>
+struct basic_file_source : private basic_file<Ch> {
+    typedef Ch char_type;
+    struct category
+        : input_seekable,
+          device_tag,
+          closable_tag
+        { };
+    using basic_file<Ch>::read;
+    using basic_file<Ch>::putback;
+    using basic_file<Ch>::seek;
+    using basic_file<Ch>::is_open;
+    using basic_file<Ch>::close;
+    basic_file_source( const std::string& path,
+                       BOOST_IOS::openmode mode = 
+                           BOOST_IOS::in )
+        : basic_file<Ch>(path, mode & ~BOOST_IOS::out, BOOST_IOS::in)
+        { }
+    void open( const std::string& path,
+               BOOST_IOS::openmode mode = BOOST_IOS::in )
+    {
+        basic_file<Ch>::open(path, mode & ~BOOST_IOS::out, BOOST_IOS::in);
+    }
+};
+
+typedef basic_file_source<char>     file_source;
+typedef basic_file_source<wchar_t>  wfile_source;
+
+template<typename Ch>
+struct basic_file_sink : private basic_file<Ch> {
+    typedef Ch char_type;
+    struct category
+        : output_seekable,
+          device_tag,
+          closable_tag,
+          flushable_tag
+        { };
+    using basic_file<Ch>::write;
+    using basic_file<Ch>::seek;
+    using basic_file<Ch>::is_open;
+    using basic_file<Ch>::close;
+    using basic_file<Ch>::flush;
+    basic_file_sink( const std::string& path,
+                     BOOST_IOS::openmode mode = BOOST_IOS::out )
+        : basic_file<Ch>(path, mode & ~BOOST_IOS::in, BOOST_IOS::out)
+        { }
+    void open( const std::string& path,
+               BOOST_IOS::openmode mode = BOOST_IOS::out )
+    {
+        basic_file<Ch>::open(path, mode & ~BOOST_IOS::in, BOOST_IOS::out);
+    }
+};
+
+typedef basic_file_sink<char>     file_sink;
+typedef basic_file_sink<wchar_t>  wfile_sink;
+                                 
+//------------------Implementation of basic_file------------------------------//
+
+template<typename Ch>
+basic_file<Ch>::basic_file
+    ( const std::string& path, BOOST_IOS::openmode mode, 
+      BOOST_IOS::openmode base_mode )
+{ 
+    open(path, mode, base_mode);
+}
+
+template<typename Ch>
+inline std::streamsize basic_file<Ch>::read
+    (char_type* s, std::streamsize n)
+{ 
+    std::streamsize result = pimpl_->file_.sgetn(s, n); 
+    return result != 0 ? result : -1;
+}
+
+template<typename Ch>
+inline bool basic_file<Ch>::putback(char_type c)
+{ 
+    return !!pimpl_->file_.sputbackc(c); 
+}
+
+template<typename Ch>
+inline std::streamsize basic_file<Ch>::write
+    (const char_type* s, std::streamsize n)
+{ return pimpl_->file_.sputn(s, n); }
+
+template<typename Ch>
+std::streampos basic_file<Ch>::seek
+    ( stream_offset off, BOOST_IOS::seekdir way, 
+      BOOST_IOS::openmode )
+{ return iostreams::seek(pimpl_->file_, off, way); }
+
+template<typename Ch>
+void basic_file<Ch>::open
+    ( const std::string& path, BOOST_IOS::openmode mode, 
+      BOOST_IOS::openmode base_mode )
+{ 
+    pimpl_.reset(new impl(path, mode | base_mode));
+}
+
+template<typename Ch>
+bool basic_file<Ch>::is_open() const { return pimpl_->file_.is_open(); }
+
+template<typename Ch>
+void basic_file<Ch>::close() { pimpl_->file_.close(); }
+
+template<typename Ch>
+bool basic_file<Ch>::flush()
+{ return pimpl_->file_.BOOST_IOSTREAMS_PUBSYNC() == 0; }
+
+//----------------------------------------------------------------------------//
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC
+
+#endif // #ifndef BOOST_IOSTREAMS_FILE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/device/file_descriptor.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/device/file_descriptor.hpp
new file mode 100644
index 0000000000..5d6af12814
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/device/file_descriptor.hpp
@@ -0,0 +1,325 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Inspired by fdstream.hpp, (C) Copyright Nicolai M. Josuttis 2001,
+// available at http://www.josuttis.com/cppcode/fdstream.html.
+
+#ifndef BOOST_IOSTREAMS_FILE_DESCRIPTOR_HPP_INCLUDED
+#define BOOST_IOSTREAMS_FILE_DESCRIPTOR_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <string>
+#include <boost/cstdint.hpp>               // intmax_t.
+#include <boost/iostreams/categories.hpp>  // tags.
+#include <boost/iostreams/detail/config/auto_link.hpp>
+#include <boost/iostreams/detail/config/dyn_link.hpp>
+#include <boost/iostreams/detail/config/windows_posix.hpp>
+#include <boost/iostreams/detail/file_handle.hpp>
+#include <boost/iostreams/detail/ios.hpp>  // openmode, seekdir, int types.
+#include <boost/iostreams/detail/path.hpp>
+#include <boost/iostreams/positioning.hpp>
+#include <boost/shared_ptr.hpp>
+
+// Must come last.
+#if defined(BOOST_MSVC)
+# pragma warning(push)
+# pragma warning(disable:4251)  // Missing DLL interface for shared_ptr
+#endif
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost { namespace iostreams {
+
+// Forward declarations
+class file_descriptor_source;
+class file_descriptor_sink;
+namespace detail { struct file_descriptor_impl; }
+
+enum file_descriptor_flags
+{
+    never_close_handle = 0,
+    close_handle = 3
+};
+
+class BOOST_IOSTREAMS_DECL file_descriptor {
+public:
+    friend class file_descriptor_source;
+    friend class file_descriptor_sink;
+    typedef detail::file_handle  handle_type;
+    typedef char                 char_type;
+    struct category
+        : seekable_device_tag,
+          closable_tag
+        { };
+
+    // Default constructor
+    file_descriptor();
+
+    // Constructors taking file desciptors
+    file_descriptor(handle_type fd, file_descriptor_flags);
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    file_descriptor(int fd, file_descriptor_flags);
+#endif
+
+#if defined(BOOST_IOSTREAMS_USE_DEPRECATED)
+    // Constructors taking file desciptors
+    explicit file_descriptor(handle_type fd, bool close_on_exit = false);
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    explicit file_descriptor(int fd, bool close_on_exit = false);
+#endif
+#endif
+
+    // Constructor taking a std:: string
+    explicit file_descriptor( const std::string& path,
+                              BOOST_IOS::openmode mode =
+                                  BOOST_IOS::in | BOOST_IOS::out );
+
+    // Constructor taking a C-style string
+    explicit file_descriptor( const char* path,
+                              BOOST_IOS::openmode mode =
+                                  BOOST_IOS::in | BOOST_IOS::out );
+
+    // Constructor taking a Boost.Filesystem path
+    template<typename Path>
+    explicit file_descriptor( const Path& path,
+                              BOOST_IOS::openmode mode =
+                                  BOOST_IOS::in | BOOST_IOS::out )
+    { 
+        init();
+        open(detail::path(path), mode); 
+    }
+
+    // Copy constructor
+    file_descriptor(const file_descriptor& other);
+
+    // open overloads taking file descriptors
+    void open(handle_type fd, file_descriptor_flags);
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    void open(int fd, file_descriptor_flags);
+#endif
+
+#if defined(BOOST_IOSTREAMS_USE_DEPRECATED)
+    // open overloads taking file descriptors
+    void open(handle_type fd, bool close_on_exit = false);
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    void open(int fd, bool close_on_exit = false);
+#endif
+#endif
+
+    // open overload taking a std::string
+    void open( const std::string& path,
+               BOOST_IOS::openmode mode =
+                   BOOST_IOS::in | BOOST_IOS::out );
+
+    // open overload taking C-style string
+    void open( const char* path,
+               BOOST_IOS::openmode mode =
+                   BOOST_IOS::in | BOOST_IOS::out );
+
+    // open overload taking a Boost.Filesystem path
+    template<typename Path>
+    void open( const Path& path,
+               BOOST_IOS::openmode mode =
+                   BOOST_IOS::in | BOOST_IOS::out )
+    { open(detail::path(path), mode); }
+
+    bool is_open() const;
+    void close();
+    std::streamsize read(char_type* s, std::streamsize n);
+    std::streamsize write(const char_type* s, std::streamsize n);
+    std::streampos seek(stream_offset off, BOOST_IOS::seekdir way);
+    handle_type handle() const;
+private:
+    void init();
+
+    // open overload taking a detail::path
+    void open( const detail::path& path, 
+               BOOST_IOS::openmode, 
+               BOOST_IOS::openmode = BOOST_IOS::openmode(0) );
+
+    typedef detail::file_descriptor_impl impl_type;
+    shared_ptr<impl_type> pimpl_;
+};
+
+class BOOST_IOSTREAMS_DECL file_descriptor_source : private file_descriptor {
+public:
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    typedef void*  handle_type;  // A.k.a HANDLE
+#else
+    typedef int    handle_type;
+#endif
+    typedef char   char_type;
+    struct category
+      : input_seekable,
+        device_tag,
+        closable_tag
+      { };
+    using file_descriptor::is_open;
+    using file_descriptor::close;
+    using file_descriptor::read;
+    using file_descriptor::seek;
+    using file_descriptor::handle;
+
+    // Default constructor
+    file_descriptor_source() { }
+
+    // Constructors taking file desciptors
+    explicit file_descriptor_source(handle_type fd, file_descriptor_flags);
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    explicit file_descriptor_source(int fd, file_descriptor_flags);
+#endif
+
+#if defined(BOOST_IOSTREAMS_USE_DEPRECATED)
+    // Constructors taking file desciptors
+    explicit file_descriptor_source(handle_type fd, bool close_on_exit = false);
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    explicit file_descriptor_source(int fd, bool close_on_exit = false);
+#endif
+#endif
+
+    // Constructor taking a std:: string
+    explicit file_descriptor_source( const std::string& path,
+                                     BOOST_IOS::openmode mode = BOOST_IOS::in );
+
+    // Constructor taking a C-style string
+    explicit file_descriptor_source( const char* path,
+                                     BOOST_IOS::openmode mode = BOOST_IOS::in );
+
+    // Constructor taking a Boost.Filesystem path
+    template<typename Path>
+    explicit file_descriptor_source( const Path& path,
+                                     BOOST_IOS::openmode mode = BOOST_IOS::in )
+    { open(detail::path(path), mode); }
+
+    // Copy constructor
+    file_descriptor_source(const file_descriptor_source& other);
+
+    // Constructors taking file desciptors
+    void open(handle_type fd, file_descriptor_flags);
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    void open(int fd, file_descriptor_flags);
+#endif
+
+#if defined(BOOST_IOSTREAMS_USE_DEPRECATED)
+    // open overloads taking file descriptors
+    void open(handle_type fd, bool close_on_exit = false);
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    void open(int fd, bool close_on_exit = false);
+#endif
+#endif
+
+    // open overload taking a std::string
+    void open(const std::string& path, BOOST_IOS::openmode mode = BOOST_IOS::in);
+
+    // open overload taking C-style string
+    void open(const char* path, BOOST_IOS::openmode mode = BOOST_IOS::in);
+
+    // open overload taking a Boost.Filesystem path
+    template<typename Path>
+    void open(const Path& path, BOOST_IOS::openmode mode = BOOST_IOS::in);
+private:
+
+    // open overload taking a detail::path
+    void open(const detail::path& path, BOOST_IOS::openmode);
+};
+
+class BOOST_IOSTREAMS_DECL file_descriptor_sink : private file_descriptor {
+public:
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    typedef void*  handle_type;  // A.k.a HANDLE
+#else
+    typedef int    handle_type;
+#endif
+    typedef char   char_type;
+    struct category
+      : output_seekable,
+        device_tag,
+        closable_tag
+      { };
+    using file_descriptor::is_open;
+    using file_descriptor::close;
+    using file_descriptor::write;
+    using file_descriptor::seek;
+    using file_descriptor::handle;
+
+    // Default constructor
+    file_descriptor_sink() { }
+
+    // Constructors taking file desciptors
+    file_descriptor_sink(handle_type fd, file_descriptor_flags);
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    file_descriptor_sink(int fd, file_descriptor_flags);
+#endif
+
+#if defined(BOOST_IOSTREAMS_USE_DEPRECATED)
+    // Constructors taking file desciptors
+    explicit file_descriptor_sink(handle_type fd, bool close_on_exit = false);
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    explicit file_descriptor_sink(int fd, bool close_on_exit = false);
+#endif
+#endif
+
+    // Constructor taking a std:: string
+    explicit file_descriptor_sink( const std::string& path,
+                                   BOOST_IOS::openmode mode = BOOST_IOS::out );
+
+    // Constructor taking a C-style string
+    explicit file_descriptor_sink( const char* path,
+                                   BOOST_IOS::openmode mode = BOOST_IOS::out );
+
+    // Constructor taking a Boost.Filesystem path
+    template<typename Path>
+    explicit file_descriptor_sink( const Path& path,
+                                   BOOST_IOS::openmode mode = BOOST_IOS::out )
+    { open(detail::path(path), mode); }
+
+    // Copy constructor
+    file_descriptor_sink(const file_descriptor_sink& other);
+
+    // open overloads taking file descriptors
+    void open(handle_type fd, file_descriptor_flags);
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    void open(int fd, file_descriptor_flags);
+#endif
+
+#if defined(BOOST_IOSTREAMS_USE_DEPRECATED)
+    // open overloads taking file descriptors
+    void open(handle_type fd, bool close_on_exit = false);
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    void open(int fd, bool close_on_exit = false);
+#endif
+#endif
+
+    // open overload taking a std::string
+    void open( const std::string& path, 
+               BOOST_IOS::openmode mode = BOOST_IOS::out );
+
+    // open overload taking C-style string
+    void open( const char* path, 
+               BOOST_IOS::openmode mode = BOOST_IOS::out );
+
+    // open overload taking a Boost.Filesystem path
+    template<typename Path>
+    void open( const Path& path, 
+               BOOST_IOS::openmode mode = BOOST_IOS::out )
+    { open(detail::path(path), mode); }
+private:
+
+    // open overload taking a detail::path
+    void open(const detail::path& path, BOOST_IOS::openmode);
+};
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+#if defined(BOOST_MSVC)
+# pragma warning(pop)  // pops #pragma warning(disable:4251)
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_FILE_DESCRIPTOR_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/device/mapped_file.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/device/mapped_file.hpp
new file mode 100644
index 0000000000..783954e7c0
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/device/mapped_file.hpp
@@ -0,0 +1,611 @@
+// (C) Copyright Jorge Lodos 2008.
+// (C) Copyright Jonathan Turkanis 2003.
+// (C) Copyright Craig Henderson 2002.   'boost/memmap.hpp' from sandbox
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.)
+
+#ifndef BOOST_IOSTREAMS_MAPPED_FILE_HPP_INCLUDED
+#define BOOST_IOSTREAMS_MAPPED_FILE_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp>                   // make sure size_t is in std.
+#include <cstddef>                            // size_t.
+#include <string>                             // pathnames.
+#include <utility>                            // pair.
+#include <boost/config.hpp>                   // BOOST_MSVC.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/close.hpp>
+#include <boost/iostreams/concepts.hpp>
+#include <boost/iostreams/detail/config/auto_link.hpp>
+#include <boost/iostreams/detail/config/dyn_link.hpp>
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#include <boost/iostreams/detail/ios.hpp>     // openmode, failure
+#include <boost/iostreams/detail/path.hpp>
+#include <boost/iostreams/operations_fwd.hpp>
+#include <boost/iostreams/positioning.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+// Must come last.
+#if defined(BOOST_MSVC)
+# pragma warning(push)
+# pragma warning(disable:4251)  // Missing DLL interface for shared_ptr
+#endif
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost { namespace iostreams {
+
+//------------------Definition of mapped_file_base and mapped_file_params-----//
+
+// Forward declarations
+class mapped_file_source;
+class mapped_file_sink;
+class mapped_file;
+namespace detail { class mapped_file_impl; }
+
+class mapped_file_base {
+public:
+    enum mapmode {
+        readonly = 1,
+        readwrite = 2,
+        priv = 4
+    };
+};
+
+// Bitmask operations for mapped_file_base::mapmode
+mapped_file_base::mapmode 
+operator|(mapped_file_base::mapmode a, mapped_file_base::mapmode b);
+
+mapped_file_base::mapmode 
+operator&(mapped_file_base::mapmode a, mapped_file_base::mapmode b);
+
+mapped_file_base::mapmode 
+operator^(mapped_file_base::mapmode a, mapped_file_base::mapmode b);
+
+mapped_file_base::mapmode 
+operator~(mapped_file_base::mapmode a);
+
+mapped_file_base::mapmode 
+operator|=(mapped_file_base::mapmode& a, mapped_file_base::mapmode b);
+
+mapped_file_base::mapmode 
+operator&=(mapped_file_base::mapmode& a, mapped_file_base::mapmode b);
+
+mapped_file_base::mapmode 
+operator^=(mapped_file_base::mapmode& a, mapped_file_base::mapmode b);
+
+//------------------Definition of mapped_file_params--------------------------//
+
+namespace detail {
+
+struct mapped_file_params_base {
+    mapped_file_params_base()
+        : flags(static_cast<mapped_file_base::mapmode>(0)), 
+          mode(), offset(0), length(static_cast<std::size_t>(-1)), 
+          new_file_size(0), hint(0)
+        { }
+private:
+    friend class mapped_file_impl;
+    void normalize();
+public:
+    mapped_file_base::mapmode   flags;
+    BOOST_IOS::openmode         mode;  // Deprecated
+    stream_offset               offset;
+    std::size_t                 length;
+    stream_offset               new_file_size;
+    const char*                 hint;
+};
+
+} // End namespace detail.
+
+// This template allows Boost.Filesystem paths to be specified when creating or
+// reopening a memory mapped file, without creating a dependence on
+// Boost.Filesystem. Possible values of Path include std::string,
+// boost::filesystem::path, boost::filesystem::wpath, 
+// and boost::iostreams::detail::path (used to store either a std::string or a
+// std::wstring).
+template<typename Path>
+struct basic_mapped_file_params 
+    : detail::mapped_file_params_base 
+{
+    typedef detail::mapped_file_params_base base_type;
+
+    // For wide paths, instantiate basic_mapped_file_params 
+    // with boost::filesystem::wpath
+#ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS
+    BOOST_STATIC_ASSERT((!is_same<Path, std::wstring>::value));
+#endif
+
+    // Default constructor
+    basic_mapped_file_params() { }
+
+    // Construction from a Path
+    explicit basic_mapped_file_params(const Path& p) : path(p) { }
+
+    // Construction from a path of a different type
+    template<typename PathT>
+    explicit basic_mapped_file_params(const PathT& p) : path(p) { }
+
+    // Copy constructor
+    basic_mapped_file_params(const basic_mapped_file_params& other)
+        : base_type(other), path(other.path)
+        { }
+
+    basic_mapped_file_params& operator=(const basic_mapped_file_params& other) = default;
+
+    // Templated copy constructor
+    template<typename PathT>
+    basic_mapped_file_params(const basic_mapped_file_params<PathT>& other)
+        : base_type(other), path(other.path)
+        { }
+
+    typedef Path  path_type;
+    Path          path;
+};
+
+typedef basic_mapped_file_params<std::string> mapped_file_params;
+
+//------------------Definition of mapped_file_source--------------------------//
+
+class BOOST_IOSTREAMS_DECL mapped_file_source : public mapped_file_base {
+private:
+    struct safe_bool_helper { int x; };
+    typedef int safe_bool_helper::*                 safe_bool;
+    typedef detail::mapped_file_impl                impl_type;
+    typedef basic_mapped_file_params<detail::path>  param_type;
+    friend class mapped_file;
+    friend class detail::mapped_file_impl;
+    friend struct boost::iostreams::operations<mapped_file_source>;
+public:
+    typedef char                                    char_type;
+    struct category
+        : public source_tag,
+          public direct_tag,
+          public closable_tag
+        { };
+    typedef std::size_t                             size_type;
+    typedef const char*                             iterator;
+    BOOST_STATIC_CONSTANT(size_type, max_length = static_cast<size_type>(-1));
+
+    // Default constructor
+    mapped_file_source();
+
+    // Constructor taking a parameters object
+    template<typename Path>
+    explicit mapped_file_source(const basic_mapped_file_params<Path>& p);
+
+    // Constructor taking a list of parameters
+    template<typename Path>
+    explicit mapped_file_source( const Path& path,
+                                 size_type length = max_length,
+                                 boost::intmax_t offset = 0 );
+
+    // Copy Constructor
+    mapped_file_source(const mapped_file_source& other);
+
+    //--------------Stream interface------------------------------------------//
+
+    template<typename Path>
+    void open(const basic_mapped_file_params<Path>& p);
+
+    template<typename Path>
+    void open( const Path& path,
+               size_type length = max_length,
+               boost::intmax_t offset = 0 );
+
+    bool is_open() const;
+    void close();
+    operator safe_bool() const;
+    bool operator!() const;
+    mapmode flags() const;
+
+    //--------------Container interface---------------------------------------//
+
+    size_type size() const;
+    const char* data() const;
+    iterator begin() const;
+    iterator end() const;
+
+    //--------------Query admissible offsets----------------------------------//
+
+    // Returns the allocation granularity for virtual memory. Values passed
+    // as offsets must be multiples of this value.
+    static int alignment();
+
+private:
+    void init();
+    void open_impl(const param_type& p);
+
+    boost::shared_ptr<impl_type> pimpl_;
+};
+
+//------------------Definition of mapped_file---------------------------------//
+
+class BOOST_IOSTREAMS_DECL mapped_file : public mapped_file_base {
+private:
+    typedef mapped_file_source                      delegate_type;
+    typedef delegate_type::safe_bool                safe_bool;
+    typedef basic_mapped_file_params<detail::path>  param_type;
+    friend struct boost::iostreams::operations<mapped_file >;
+    friend class mapped_file_sink;
+public:
+    typedef char                                    char_type;
+    struct category
+        : public seekable_device_tag,
+          public direct_tag,
+          public closable_tag
+        { };
+    typedef mapped_file_source::size_type           size_type;
+    typedef char*                                   iterator;
+    typedef const char*                             const_iterator;
+    BOOST_STATIC_CONSTANT(size_type, max_length = delegate_type::max_length);
+
+    // Default constructor
+    mapped_file() { }
+
+    // Construstor taking a parameters object
+    template<typename Path>
+    explicit mapped_file(const basic_mapped_file_params<Path>& p);
+
+    // Constructor taking a list of parameters
+    template<typename Path>
+    mapped_file( const Path& path,
+                 mapmode flags,
+                 size_type length = max_length,
+                 stream_offset offset = 0 );
+
+    // Constructor taking a list of parameters, including a 
+    // std::ios_base::openmode (deprecated)
+    template<typename Path>
+    explicit mapped_file( const Path& path,
+                          BOOST_IOS::openmode mode =
+                              BOOST_IOS::in | BOOST_IOS::out,
+                          size_type length = max_length,
+                          stream_offset offset = 0 );
+
+    // Copy Constructor
+    mapped_file(const mapped_file& other);
+
+    //--------------Conversion to mapped_file_source (deprecated)-------------//
+
+    operator mapped_file_source&() { return delegate_; }
+    operator const mapped_file_source&() const { return delegate_; }
+
+    //--------------Stream interface------------------------------------------//
+
+    // open overload taking a parameters object
+    template<typename Path>
+    void open(const basic_mapped_file_params<Path>& p);
+
+    // open overload taking a list of parameters
+    template<typename Path>
+    void open( const Path& path,
+               mapmode mode,
+               size_type length = max_length,
+               stream_offset offset = 0 );
+
+    // open overload taking a list of parameters, including a 
+    // std::ios_base::openmode (deprecated)
+    template<typename Path>
+    void open( const Path& path,
+               BOOST_IOS::openmode mode =
+                   BOOST_IOS::in | BOOST_IOS::out,
+               size_type length = max_length,
+               stream_offset offset = 0 );
+
+    bool is_open() const { return delegate_.is_open(); }
+    void close() { delegate_.close(); }
+    operator safe_bool() const { return delegate_; }
+    bool operator!() const { return !delegate_; }
+    mapmode flags() const { return delegate_.flags(); }
+
+    //--------------Container interface---------------------------------------//
+
+    size_type size() const { return delegate_.size(); }
+    char* data() const;
+    const char* const_data() const { return delegate_.data(); }
+    iterator begin() const { return data(); }
+    const_iterator const_begin() const { return const_data(); }
+    iterator end() const;
+    const_iterator const_end() const { return const_data() + size(); }
+
+    //--------------Query admissible offsets----------------------------------//
+
+    // Returns the allocation granularity for virtual memory. Values passed
+    // as offsets must be multiples of this value.
+    static int alignment() { return mapped_file_source::alignment(); }
+
+    //--------------File access----------------------------------------------//
+
+    void resize(stream_offset new_size);
+private:
+    delegate_type delegate_;
+};
+
+//------------------Definition of mapped_file_sink----------------------------//
+
+class BOOST_IOSTREAMS_DECL mapped_file_sink : private mapped_file {
+public:
+    friend struct boost::iostreams::operations<mapped_file_sink>;
+    using mapped_file::mapmode;
+    using mapped_file::readonly;
+    using mapped_file::readwrite;
+    using mapped_file::priv;
+    using mapped_file::char_type;
+    struct category
+        : public sink_tag,
+          public direct_tag,
+          public closable_tag
+        { };
+    using mapped_file::size_type;
+    using mapped_file::iterator;
+    using mapped_file::max_length;
+    using mapped_file::is_open;
+    using mapped_file::close;
+    using mapped_file::operator safe_bool;
+    using mapped_file::operator !;
+    using mapped_file::flags;
+    using mapped_file::size;
+    using mapped_file::data;
+    using mapped_file::begin;
+    using mapped_file::end;
+    using mapped_file::alignment;
+    using mapped_file::resize;
+
+    // Default constructor
+    mapped_file_sink() { }
+
+    // Constructor taking a parameters object
+    template<typename Path>
+    explicit mapped_file_sink(const basic_mapped_file_params<Path>& p);
+
+    // Constructor taking a list of parameters
+    template<typename Path>
+    explicit mapped_file_sink( const Path& path,
+                               size_type length = max_length,
+                               boost::intmax_t offset = 0,
+                               mapmode flags = readwrite );
+
+    // Copy Constructor
+    mapped_file_sink(const mapped_file_sink& other);
+
+    // open overload taking a parameters object
+    template<typename Path>
+    void open(const basic_mapped_file_params<Path>& p);
+
+    // open overload taking a list of parameters
+    template<typename Path>
+    void open( const Path& path,
+               size_type length = max_length,
+               boost::intmax_t offset = 0,
+               mapmode flags = readwrite );
+};
+
+//------------------Implementation of mapped_file_source----------------------//
+
+template<typename Path>
+mapped_file_source::mapped_file_source(const basic_mapped_file_params<Path>& p)
+{ init(); open(p); }
+
+template<typename Path>
+mapped_file_source::mapped_file_source( 
+    const Path& path, size_type length, boost::intmax_t offset)
+{ init(); open(path, length, offset); }
+
+template<typename Path>
+void mapped_file_source::open(const basic_mapped_file_params<Path>& p)
+{
+    param_type params(p);
+    if (params.flags) {
+        if (params.flags != mapped_file::readonly)
+            boost::throw_exception(BOOST_IOSTREAMS_FAILURE("invalid flags"));
+    } else {
+        if (params.mode & BOOST_IOS::out)
+            boost::throw_exception(BOOST_IOSTREAMS_FAILURE("invalid mode"));
+        params.mode |= BOOST_IOS::in;
+    }
+    open_impl(params);
+}
+
+template<typename Path>
+void mapped_file_source::open(
+    const Path& path, size_type length, boost::intmax_t offset)
+{
+    param_type p(path);
+    p.length = length;
+    p.offset = offset;
+    open(p);
+}
+
+//------------------Implementation of mapped_file-----------------------------//
+
+template<typename Path>
+mapped_file::mapped_file(const basic_mapped_file_params<Path>& p)
+{ open(p); }
+
+template<typename Path>
+mapped_file::mapped_file( 
+    const Path& path, mapmode flags, 
+    size_type length, stream_offset offset )
+{ open(path, flags, length, offset); }
+
+template<typename Path>
+mapped_file::mapped_file( 
+    const Path& path, BOOST_IOS::openmode mode, 
+    size_type length, stream_offset offset )
+{ open(path, mode, length, offset); }
+
+template<typename Path>
+void mapped_file::open(const basic_mapped_file_params<Path>& p)
+{ delegate_.open_impl(p); }
+
+template<typename Path>
+void mapped_file::open( 
+    const Path& path, mapmode flags, 
+    size_type length, stream_offset offset )
+{
+    param_type p(path);
+    p.flags = flags;
+    p.length = length;
+    p.offset = offset;
+    open(p);
+}
+
+template<typename Path>
+void mapped_file::open( 
+    const Path& path, BOOST_IOS::openmode mode, 
+    size_type length, stream_offset offset )
+{
+    param_type p(path);
+    p.mode = mode;
+    p.length = length;
+    p.offset = offset;
+    open(p);
+}
+
+inline char* mapped_file::data() const 
+{ return (flags() != readonly) ? const_cast<char*>(delegate_.data()) : 0; }
+
+inline mapped_file::iterator mapped_file::end() const 
+{ return (flags() != readonly) ? data() + size() : 0; }
+
+//------------------Implementation of mapped_file_sink------------------------//
+
+template<typename Path>
+mapped_file_sink::mapped_file_sink(const basic_mapped_file_params<Path>& p)
+{ open(p); }
+
+template<typename Path>
+mapped_file_sink::mapped_file_sink(
+    const Path& path, size_type length,
+    boost::intmax_t offset, mapmode flags )
+{ open(path, length, offset, flags); }
+
+template<typename Path>
+void mapped_file_sink::open(const basic_mapped_file_params<Path>& p)
+{
+    param_type params(p);
+    if (params.flags) {
+        if (params.flags & mapped_file::readonly)
+            boost::throw_exception(BOOST_IOSTREAMS_FAILURE("invalid flags"));
+    } else {
+        if (params.mode & BOOST_IOS::in)
+            boost::throw_exception(BOOST_IOSTREAMS_FAILURE("invalid mode"));
+        params.mode |= BOOST_IOS::out;
+    }
+    mapped_file::open(params);
+}
+
+template<typename Path>
+void mapped_file_sink::open(
+    const Path& path, size_type length,
+    boost::intmax_t offset, mapmode flags )
+{
+    param_type p(path);
+    p.flags = flags;
+    p.length = length;
+    p.offset = offset;
+    open(p);
+}
+
+//------------------Specialization of direct_impl-----------------------------//
+
+template<>
+struct operations<mapped_file_source>
+    : boost::iostreams::detail::close_impl<closable_tag>
+{
+    static std::pair<char*, char*>
+    input_sequence(mapped_file_source& src)
+    {
+        return std::make_pair( const_cast<char*>(src.begin()),
+                               const_cast<char*>(src.end()) );
+    }
+};
+
+template<>
+struct operations<mapped_file>
+    : boost::iostreams::detail::close_impl<closable_tag>
+{
+    static std::pair<char*, char*>
+    input_sequence(mapped_file& file)
+    { 
+        return std::make_pair(file.begin(), file.end()); 
+    }
+    static std::pair<char*, char*>
+    output_sequence(mapped_file& file)
+    { 
+        return std::make_pair(file.begin(), file.end()); 
+    }
+};
+
+template<>
+struct operations<mapped_file_sink>
+    : boost::iostreams::detail::close_impl<closable_tag>
+{
+    static std::pair<char*, char*>
+    output_sequence(mapped_file_sink& sink)
+    { 
+        return std::make_pair(sink.begin(), sink.end()); 
+    }
+};
+                    
+//------------------Definition of mapmode operators---------------------------//
+
+inline mapped_file::mapmode 
+operator|(mapped_file::mapmode a, mapped_file::mapmode b)
+{
+    return static_cast<mapped_file::mapmode>
+        (static_cast<int>(a) | static_cast<int>(b));
+}
+
+inline mapped_file::mapmode 
+operator&(mapped_file::mapmode a, mapped_file::mapmode b)
+{
+    return static_cast<mapped_file::mapmode>
+        (static_cast<int>(a) & static_cast<int>(b));
+}
+
+inline mapped_file::mapmode 
+operator^(mapped_file::mapmode a, mapped_file::mapmode b)
+{
+    return static_cast<mapped_file::mapmode>
+        (static_cast<int>(a) ^ static_cast<int>(b));
+}
+
+inline mapped_file::mapmode
+operator~(mapped_file::mapmode a)
+{
+    return static_cast<mapped_file::mapmode>(~static_cast<int>(a));
+}
+
+inline mapped_file::mapmode 
+operator|=(mapped_file::mapmode& a, mapped_file::mapmode b)
+{
+    return a = a | b;
+}
+
+inline mapped_file::mapmode 
+operator&=(mapped_file::mapmode& a, mapped_file::mapmode b)
+{
+    return a = a & b;
+}
+
+inline mapped_file::mapmode 
+operator^=(mapped_file::mapmode& a, mapped_file::mapmode b)
+{
+    return a = a ^ b;
+}
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+#if defined(BOOST_MSVC)
+# pragma warning(pop)  // pops #pragma warning(disable:4251)
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_MAPPED_FILE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/device/null.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/device/null.hpp
new file mode 100644
index 0000000000..a3943d7436
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/device/null.hpp
@@ -0,0 +1,66 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2004-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Inspired by Daryle Walker's nullbuf from his More I/O submission.
+
+#ifndef BOOST_IOSTREAMS_NULL_HPP_INCLUDED
+#define BOOST_IOSTREAMS_NULL_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/iostreams/categories.hpp>
+#include <boost/iostreams/detail/ios.hpp> // openmode, streamsize.
+#include <boost/iostreams/positioning.hpp>
+
+namespace boost { namespace iostreams {
+
+template<typename Ch, typename Mode>
+class basic_null_device {
+public:
+    typedef Ch char_type;
+    struct category
+        : public Mode,
+          public device_tag,
+          public closable_tag
+        { };
+    std::streamsize read(Ch*, std::streamsize) { return -1; }
+    std::streamsize write(const Ch*, std::streamsize n) { return n; }
+    std::streampos seek( stream_offset, BOOST_IOS::seekdir,
+                         BOOST_IOS::openmode = 
+                             BOOST_IOS::in | BOOST_IOS::out ) 
+    { return -1; }
+    void close() { }
+    void close(BOOST_IOS::openmode) { }
+};
+
+template<typename Ch>
+struct basic_null_source : private basic_null_device<Ch, input> {
+    typedef Ch          char_type;
+    typedef source_tag  category;
+    using basic_null_device<Ch, input>::read;
+    using basic_null_device<Ch, input>::close;
+};
+
+typedef basic_null_source<char>     null_source;
+typedef basic_null_source<wchar_t>  wnull_source;
+
+template<typename Ch>
+struct basic_null_sink : private basic_null_device<Ch, output> {
+    typedef Ch        char_type;
+    typedef sink_tag  category;
+    using basic_null_device<Ch, output>::write;
+    using basic_null_device<Ch, output>::close;
+};
+
+typedef basic_null_sink<char>     null_sink;
+typedef basic_null_sink<wchar_t>  wnull_sink;
+
+} } // End namespaces iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_NULL_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/filter/bzip2.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/filter/bzip2.hpp
new file mode 100644
index 0000000000..b9c04a7ce1
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/filter/bzip2.hpp
@@ -0,0 +1,418 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Note: custom allocators are not supported on VC6, since that compiler
+// had trouble finding the function zlib_base::do_init.
+
+#ifndef BOOST_IOSTREAMS_BZIP2_HPP_INCLUDED
+#define BOOST_IOSTREAMS_BZIP2_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+                   
+#include <cassert>                            
+#include <memory>            // allocator.
+#include <new>               // bad_alloc.
+#include <boost/config.hpp>  // MSVC, STATIC_CONSTANT, DEDUCED_TYPENAME, DINKUM.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/constants.hpp>   // buffer size.
+#include <boost/iostreams/detail/config/auto_link.hpp>
+#include <boost/iostreams/detail/config/bzip2.hpp>
+#include <boost/iostreams/detail/config/dyn_link.hpp>
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#include <boost/iostreams/detail/ios.hpp>  // failure, streamsize.
+#include <boost/iostreams/filter/symmetric.hpp>               
+#include <boost/iostreams/pipeline.hpp>       
+#include <boost/type_traits/is_same.hpp>     
+
+// Must come last.
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable:4251 4231 4660)
+#endif
+#include <boost/config/abi_prefix.hpp>           
+
+// Temporary fix.
+#undef small
+
+namespace boost { namespace iostreams {
+
+namespace bzip2 {
+
+                    // Typedefs.
+
+typedef void* (*alloc_func)(void*, int, int);
+typedef void (*free_func)(void*, void*);
+
+                    // Status codes
+
+BOOST_IOSTREAMS_DECL extern const int ok;
+BOOST_IOSTREAMS_DECL extern const int run_ok;
+BOOST_IOSTREAMS_DECL extern const int flush_ok;
+BOOST_IOSTREAMS_DECL extern const int finish_ok;
+BOOST_IOSTREAMS_DECL extern const int stream_end;    
+BOOST_IOSTREAMS_DECL extern const int sequence_error;
+BOOST_IOSTREAMS_DECL extern const int param_error;
+BOOST_IOSTREAMS_DECL extern const int mem_error;
+BOOST_IOSTREAMS_DECL extern const int data_error;
+BOOST_IOSTREAMS_DECL extern const int data_error_magic;
+BOOST_IOSTREAMS_DECL extern const int io_error;
+BOOST_IOSTREAMS_DECL extern const int unexpected_eof;
+BOOST_IOSTREAMS_DECL extern const int outbuff_full;
+BOOST_IOSTREAMS_DECL extern const int config_error;
+
+                    // Action codes
+
+BOOST_IOSTREAMS_DECL extern const int finish;
+BOOST_IOSTREAMS_DECL extern const int run;
+
+                    // Default values
+
+const int default_block_size   = 9;
+const int default_work_factor  = 30;
+const bool default_small       = false;
+
+} // End namespace bzip2. 
+
+//
+// Class name: bzip2_params.
+// Description: Encapsulates the parameters passed to deflateInit2
+//      to customize compression.
+//
+struct bzip2_params {
+
+    // Non-explicit constructor for compression.
+    bzip2_params( int block_size_  = bzip2::default_block_size,
+                  int work_factor_ = bzip2::default_work_factor )
+        : block_size(block_size_), work_factor(work_factor_)
+        { }
+
+    // Constructor for decompression.
+    bzip2_params(bool small)
+        : small(small), work_factor(0)
+        { }
+
+    union {
+        int   block_size;    // For compression.
+        bool  small;         // For decompression.
+    };
+    int       work_factor;
+};
+
+//
+// Class name: bzip2_error.
+// Description: Subclass of std::ios_base::failure thrown to indicate
+//     bzip2 errors other than out-of-memory conditions.
+//
+class BOOST_IOSTREAMS_DECL bzip2_error : public BOOST_IOSTREAMS_FAILURE {
+public:
+    explicit bzip2_error(int error);
+    int error() const { return error_; }
+    static void check BOOST_PREVENT_MACRO_SUBSTITUTION(int error);
+private:
+    int error_;
+};
+
+namespace detail {
+
+template<typename Alloc>
+struct bzip2_allocator_traits {
+#ifndef BOOST_NO_STD_ALLOCATOR
+#if defined(BOOST_NO_CXX11_ALLOCATOR)
+    typedef typename Alloc::template rebind<char>::other type;
+#else
+    typedef typename std::allocator_traits<Alloc>::template rebind_alloc<char> type;
+#endif
+#else
+    typedef std::allocator<char> type;
+#endif
+};
+
+template< typename Alloc,
+          typename Base = // VC6 workaround (C2516)
+              BOOST_DEDUCED_TYPENAME bzip2_allocator_traits<Alloc>::type >
+struct bzip2_allocator : private Base {
+private:
+#if defined(BOOST_NO_CXX11_ALLOCATOR) || defined(BOOST_NO_STD_ALLOCATOR)
+    typedef typename Base::size_type size_type;
+#else
+    typedef typename std::allocator_traits<Base>::size_type size_type;
+#endif
+public:
+    BOOST_STATIC_CONSTANT(bool, custom = 
+        (!is_same<std::allocator<char>, Base>::value));
+    typedef typename bzip2_allocator_traits<Alloc>::type allocator_type;
+    static void* allocate(void* self, int items, int size);
+    static void deallocate(void* self, void* address);
+};
+
+class BOOST_IOSTREAMS_DECL bzip2_base  { 
+public:
+    typedef char char_type;
+protected:
+    bzip2_base(const bzip2_params& params);
+    ~bzip2_base();
+    bzip2_params& params() { return params_; }
+    bool& ready() { return ready_; }
+    template<typename Alloc> 
+    void init( bool compress,
+               bzip2_allocator<Alloc>& alloc )
+        {
+            bool custom = bzip2_allocator<Alloc>::custom;
+            do_init( compress,
+                     custom ? bzip2_allocator<Alloc>::allocate : 0,
+                     custom ? bzip2_allocator<Alloc>::deallocate : 0,
+                     custom ? &alloc : 0 );
+        }
+    void before( const char*& src_begin, const char* src_end,
+                 char*& dest_begin, char* dest_end );
+    void after(const char*& src_begin, char*& dest_begin);
+    int check_end(const char* src_begin, const char* dest_begin);
+    int compress(int action);
+    int decompress();
+    void end(bool compress);
+private:
+    void do_init( bool compress, 
+                  bzip2::alloc_func,
+                  bzip2::free_func, 
+                  void* derived );
+    bzip2_params  params_;
+    void*         stream_; // Actual type: bz_stream*.
+    bool          ready_;
+};
+
+//
+// Template name: bzip2_compressor_impl
+// Description: Model of SymmetricFilter implementing compression by
+//      delegating to the libbzip2 function BZ_bzCompress.
+//
+template<typename Alloc = std::allocator<char> >
+class bzip2_compressor_impl 
+    : public bzip2_base, 
+      #if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+          public
+      #endif
+      bzip2_allocator<Alloc> 
+{
+public: 
+    bzip2_compressor_impl(const bzip2_params&);
+    bool filter( const char*& src_begin, const char* src_end,
+                 char*& dest_begin, char* dest_end, bool flush );
+    void close();
+private:
+    void init();
+    bool eof_; // Guard to make sure filter() isn't called after it returns false.
+};
+
+//
+// Template name: bzip2_compressor
+// Description: Model of SymmetricFilter implementing decompression by
+//      delegating to the libbzip2 function BZ_bzDecompress.
+//
+template<typename Alloc = std::allocator<char> >
+class bzip2_decompressor_impl 
+    : public bzip2_base, 
+      #if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+          public
+      #endif
+      bzip2_allocator<Alloc> 
+{ 
+public:
+    bzip2_decompressor_impl(bool small = bzip2::default_small);
+    bool filter( const char*& begin_in, const char* end_in,
+                 char*& begin_out, char* end_out, bool flush );
+    void close();
+private:
+    void init();
+    bool eof_; // Guard to make sure filter() isn't called after it returns false.
+};
+
+} // End namespace detail.
+
+//
+// Template name: bzip2_compressor
+// Description: Model of InputFilter and OutputFilter implementing
+//      compression using libbzip2.
+//
+template<typename Alloc = std::allocator<char> >
+struct basic_bzip2_compressor 
+    : symmetric_filter<detail::bzip2_compressor_impl<Alloc>, Alloc> 
+{
+private:
+    typedef detail::bzip2_compressor_impl<Alloc>        impl_type;
+    typedef symmetric_filter<impl_type, Alloc>  base_type;
+public:
+    typedef typename base_type::char_type               char_type;
+    typedef typename base_type::category                category;
+    basic_bzip2_compressor( const bzip2_params& = bzip2::default_block_size, 
+                            std::streamsize buffer_size =  default_device_buffer_size );
+};
+BOOST_IOSTREAMS_PIPABLE(basic_bzip2_compressor, 1)
+
+typedef basic_bzip2_compressor<> bzip2_compressor;
+
+//
+// Template name: bzip2_decompressor
+// Description: Model of InputFilter and OutputFilter implementing
+//      decompression using libbzip2.
+//
+template<typename Alloc = std::allocator<char> >
+struct basic_bzip2_decompressor 
+    : symmetric_filter<detail::bzip2_decompressor_impl<Alloc>, Alloc> 
+{
+private:
+    typedef detail::bzip2_decompressor_impl<Alloc>      impl_type;
+    typedef symmetric_filter<impl_type, Alloc>  base_type;
+public:
+    typedef typename base_type::char_type               char_type;
+    typedef typename base_type::category                category;
+    basic_bzip2_decompressor( bool small = bzip2::default_small,
+                              std::streamsize buffer_size = default_device_buffer_size );
+};
+BOOST_IOSTREAMS_PIPABLE(basic_bzip2_decompressor, 1)
+
+typedef basic_bzip2_decompressor<> bzip2_decompressor;
+
+//----------------------------------------------------------------------------//
+
+//------------------Implementation of bzip2_allocator-------------------------//
+
+namespace detail {
+
+template<typename Alloc, typename Base>
+void* bzip2_allocator<Alloc, Base>::allocate(void* self, int items, int size)
+{ 
+    size_type len = items * size;
+    char* ptr = 
+        static_cast<allocator_type*>(self)->allocate
+            (len + sizeof(size_type)
+            #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+                , (char*)0
+            #endif
+            );
+    *reinterpret_cast<size_type*>(ptr) = len;
+    return ptr + sizeof(size_type);
+}
+
+template<typename Alloc, typename Base>
+void bzip2_allocator<Alloc, Base>::deallocate(void* self, void* address)
+{ 
+    char* ptr = reinterpret_cast<char*>(address) - sizeof(size_type);
+    size_type len = *reinterpret_cast<size_type*>(ptr) + sizeof(size_type);
+    static_cast<allocator_type*>(self)->deallocate(ptr, len); 
+}
+
+//------------------Implementation of bzip2_compressor_impl-------------------//
+
+template<typename Alloc>
+bzip2_compressor_impl<Alloc>::bzip2_compressor_impl(const bzip2_params& p)
+    : bzip2_base(p), eof_(false) { }
+
+template<typename Alloc>
+bool bzip2_compressor_impl<Alloc>::filter
+    ( const char*& src_begin, const char* src_end,
+      char*& dest_begin, char* dest_end, bool flush )
+{
+    if (!ready()) init();
+    if (eof_) return false;
+    before(src_begin, src_end, dest_begin, dest_end);
+    int result = compress(flush ? bzip2::finish : bzip2::run);
+    after(src_begin, dest_begin);
+    bzip2_error::check BOOST_PREVENT_MACRO_SUBSTITUTION(result);
+    return !(eof_ = result == bzip2::stream_end);
+}
+
+template<typename Alloc>
+void bzip2_compressor_impl<Alloc>::close() 
+{ 
+    try {
+        end(true);
+    } catch (...) { 
+        eof_ = false; 
+        throw;
+    }
+    eof_ = false;
+}
+
+template<typename Alloc>
+inline void bzip2_compressor_impl<Alloc>::init() 
+{ bzip2_base::init(true, static_cast<bzip2_allocator<Alloc>&>(*this)); }
+
+//------------------Implementation of bzip2_decompressor_impl-----------------//
+
+template<typename Alloc>
+bzip2_decompressor_impl<Alloc>::bzip2_decompressor_impl(bool small)
+    : bzip2_base(bzip2_params(small)), eof_(false) { }
+
+template<typename Alloc>
+bool bzip2_decompressor_impl<Alloc>::filter
+    ( const char*& src_begin, const char* src_end,
+      char*& dest_begin, char* dest_end, bool flush )
+{
+    if (eof_) {
+        // reset the stream if there are more characters
+        if(src_begin == src_end)
+            return false;
+        else
+            close();
+    }
+    if (!ready()) 
+        init();
+    before(src_begin, src_end, dest_begin, dest_end);
+    int result = decompress();
+    if(result == bzip2::ok && flush)
+        result = check_end(src_begin, dest_begin);
+    after(src_begin, dest_begin);
+    bzip2_error::check BOOST_PREVENT_MACRO_SUBSTITUTION(result);
+    eof_ = result == bzip2::stream_end;
+    return true; 
+}
+
+template<typename Alloc>
+void bzip2_decompressor_impl<Alloc>::close() 
+{ 
+    try {
+        end(false);
+    } catch (...) { 
+        eof_ = false; 
+        throw;
+    }
+    eof_ = false;
+}
+
+template<typename Alloc>
+inline void bzip2_decompressor_impl<Alloc>::init()
+{ bzip2_base::init(false, static_cast<bzip2_allocator<Alloc>&>(*this)); }
+} // End namespace detail.
+
+//------------------Implementation of bzip2_decompressor----------------------//
+
+template<typename Alloc>
+basic_bzip2_compressor<Alloc>::basic_bzip2_compressor
+        (const bzip2_params& p, std::streamsize buffer_size) 
+    : base_type(buffer_size, p) 
+    { }
+
+//------------------Implementation of bzip2_decompressor----------------------//
+
+template<typename Alloc>
+basic_bzip2_decompressor<Alloc>::basic_bzip2_decompressor
+        (bool small, std::streamsize buffer_size) 
+    : base_type(buffer_size, small)
+    { }
+
+//----------------------------------------------------------------------------//
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/config/abi_suffix.hpp> // Pops abi_suffix.hpp pragmas.
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_BZIP2_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/filter/gzip.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/filter/gzip.hpp
new file mode 100644
index 0000000000..e236983e0b
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/filter/gzip.hpp
@@ -0,0 +1,757 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Contains the definitions of the class templates gzip_compressor and
+// gzip_decompressor for reading and writing files in the gzip file format
+// (RFC 1952). Based in part on work of Jonathan de Halleux; see [...]
+
+#ifndef BOOST_IOSTREAMS_GZIP_HPP_INCLUDED
+#define BOOST_IOSTREAMS_GZIP_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp> // STATIC_CONSTANT, STDC_NAMESPACE, 
+                            // DINKUMWARE_STDLIB, __STL_CONFIG_H.
+#include <algorithm>                      // min.
+#include <boost/assert.hpp>
+#include <cstdio>                         // EOF.
+#include <cstddef>                        // size_t.
+#include <ctime>                          // std::time_t.
+#include <memory>                         // allocator.
+#include <boost/config.hpp>               // Put size_t in std.
+#include <boost/detail/workaround.hpp>
+#include <boost/cstdint.hpp>              // uint8_t, uint32_t.
+#include <boost/iostreams/checked_operations.hpp>
+#include <boost/iostreams/constants.hpp>  // buffer size.
+#include <boost/iostreams/detail/adapter/non_blocking_adapter.hpp>
+#include <boost/iostreams/detail/adapter/range_adapter.hpp>
+#include <boost/iostreams/detail/char_traits.hpp>
+#include <boost/iostreams/detail/ios.hpp> // failure, streamsize.
+#include <boost/iostreams/detail/error.hpp>
+#include <boost/iostreams/operations.hpp>
+#include <boost/iostreams/device/back_inserter.hpp>
+#include <boost/iostreams/filter/zlib.hpp>
+#include <boost/iostreams/pipeline.hpp>     
+#include <boost/iostreams/putback.hpp>
+#include <boost/throw_exception.hpp>
+
+// Must come last.
+#if defined(BOOST_MSVC)
+# pragma warning(push)
+# pragma warning(disable:4244)    // Possible truncation
+# pragma warning(disable:4251)    // Missing DLL interface for std::string
+# pragma warning(disable:4309)    // Truncation of constant value.
+#endif
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std { using ::time_t; }
+#endif
+
+namespace boost { namespace iostreams {
+                    
+//------------------Definitions of constants----------------------------------//
+
+namespace gzip {
+
+using namespace boost::iostreams::zlib;
+
+    // Error codes used by gzip_error.
+
+const int zlib_error        = 1;
+const int bad_crc           = 2; // Recorded crc doesn't match data.
+const int bad_length        = 3; // Recorded length doesn't match data.
+const int bad_header        = 4; // Malformed header.
+const int bad_footer        = 5; // Malformed footer.
+const int bad_method        = 6; // Unsupported compression method.
+
+namespace magic {
+
+    // Magic numbers used by gzip header.
+
+const int id1               = 0x1f;
+const int id2               = 0x8b;
+
+} // End namespace magic.
+
+namespace method {
+
+    // Codes used for the 'CM' byte of the gzip header.
+
+const int deflate           = 8;
+
+} // End namespace method.
+
+namespace flags {
+
+    // Codes used for the 'FLG' byte of the gzip header.
+
+const int text              = 1;
+const int header_crc        = 2;
+const int extra             = 4;
+const int name              = 8;
+const int comment           = 16;
+
+} // End namespace flags.
+
+namespace extra_flags {
+
+    // Codes used for the 'XFL' byte of the gzip header.
+
+const int best_compression  = 2;
+const int best_speed        = 4;
+
+} // End namespace extra_flags.
+
+    // Codes used for the 'OS' byte of the gzip header.
+
+const int os_fat            = 0;
+const int os_amiga          = 1;
+const int os_vms            = 2;
+const int os_unix           = 3;
+const int os_vm_cms         = 4;
+const int os_atari          = 5;
+const int os_hpfs           = 6;
+const int os_macintosh      = 7;
+const int os_z_system       = 8;
+const int os_cp_m           = 9;
+const int os_tops_20        = 10;
+const int os_ntfs           = 11;
+const int os_qdos           = 12;
+const int os_acorn          = 13;
+const int os_unknown        = 255;
+
+} // End namespace gzip.
+
+//------------------Definition of gzip_params---------------------------------//
+
+//
+// Class name: gzip_params.
+// Description: Subclass of zlib_params with an additional field
+//      representing a file name.
+//
+struct gzip_params : zlib_params {
+
+    // Non-explicit constructor.
+    gzip_params( int level              = gzip::default_compression,
+                 int method             = gzip::deflated,
+                 int window_bits        = gzip::default_window_bits,
+                 int mem_level          = gzip::default_mem_level,
+                 int strategy           = gzip::default_strategy,
+                 std::string file_name_  = "",
+                 std::string comment_    = "",
+                 std::time_t mtime_      = 0 )
+        : zlib_params(level, method, window_bits, mem_level, strategy),
+          file_name(file_name_), comment(comment_), mtime(mtime_)
+        { }
+    std::string  file_name;
+    std::string  comment;
+    std::time_t  mtime;
+};
+
+//------------------Definition of gzip_error----------------------------------//
+
+//
+// Class name: gzip_error.
+// Description: Subclass of std::ios_base::failure thrown to indicate
+//     zlib errors other than out-of-memory conditions.
+//
+class gzip_error : public BOOST_IOSTREAMS_FAILURE {
+public:
+    explicit gzip_error(int error)
+        : BOOST_IOSTREAMS_FAILURE("gzip error"),
+          error_(error), zlib_error_code_(zlib::okay) { }
+    explicit gzip_error(const zlib_error& e)
+        : BOOST_IOSTREAMS_FAILURE("gzip error"),
+          error_(gzip::zlib_error), zlib_error_code_(e.error())
+        { }
+    int error() const { return error_; }
+    int zlib_error_code() const { return zlib_error_code_; }
+private:
+    int error_;
+    int zlib_error_code_;
+};
+
+//------------------Definition of gzip_compressor-----------------------------//
+
+//
+// Template name: gzip_compressor
+// Description: Model of OutputFilter implementing compression in the
+//      gzip format.
+//
+template<typename Alloc = std::allocator<char> >
+class basic_gzip_compressor : basic_zlib_compressor<Alloc> {
+private:
+    typedef basic_zlib_compressor<Alloc>  base_type;
+public:
+    typedef char char_type;
+    struct category
+        : dual_use,
+          filter_tag,
+          multichar_tag,
+          closable_tag
+        { };
+    basic_gzip_compressor( const gzip_params& = gzip::default_compression,
+                           std::streamsize buffer_size = default_device_buffer_size );
+
+    template<typename Source>
+    std::streamsize read(Source& src, char_type* s, std::streamsize n)
+    {
+        std::streamsize result = 0;
+
+        // Read header.
+        if (!(flags_ & f_header_done))
+            result += read_string(s, n, header_);
+
+        // Read body.
+        if (!(flags_ & f_body_done)) {
+
+            // Read from basic_zlib_filter.
+            std::streamsize amt = base_type::read(src, s + result, n - result);
+            if (amt != -1) {
+                result += amt;
+                if (amt < n - result) { // Double-check for EOF.
+                    amt = base_type::read(src, s + result, n - result);
+                    if (amt != -1)
+                        result += amt;
+                }
+            }
+            if (amt == -1)
+                prepare_footer();
+        }
+
+        // Read footer.
+        if ((flags_ & f_body_done) != 0 && result < n)
+            result += read_string(s + result, n - result, footer_);
+
+        return result != 0 ? result : -1;
+    }
+
+    template<typename Sink>
+    std::streamsize write(Sink& snk, const char_type* s, std::streamsize n)
+    {
+        if (!(flags_ & f_header_done)) {
+            std::streamsize amt = 
+                static_cast<std::streamsize>(header_.size() - offset_);
+            offset_ += boost::iostreams::write_if(snk, header_.data() + offset_, amt);
+            if (offset_ == header_.size())
+                flags_ |= f_header_done;
+            else
+                return 0;
+        }
+        return base_type::write(snk, s, n);
+    }
+
+    template<typename Sink>
+    void close(Sink& snk, BOOST_IOS::openmode m)
+    {
+        try {
+            if (m == BOOST_IOS::out && !(flags_ & f_header_done))
+                this->write(snk, 0, 0);
+
+            // Close zlib compressor.
+            base_type::close(snk, m);
+
+            if (m == BOOST_IOS::out) {
+                if (flags_ & f_header_done) {
+
+                    // Write final fields of gzip file format.
+                    write_long(this->crc(), snk);
+                    write_long(this->total_in(), snk);
+                }
+            }
+        } catch(...) {
+            close_impl();
+            throw;
+        }
+        close_impl();
+    }
+private:
+    static gzip_params normalize_params(gzip_params p);
+    void prepare_footer();
+    std::streamsize read_string(char* s, std::streamsize n, std::string& str);
+
+    template<typename Sink>
+    static void write_long(long n, Sink& next, boost::mpl::true_)
+    {
+        boost::iostreams::put(next, static_cast<char>(0xFF & n));
+        boost::iostreams::put(next, static_cast<char>(0xFF & (n >> 8)));
+        boost::iostreams::put(next, static_cast<char>(0xFF & (n >> 16)));
+        boost::iostreams::put(next, static_cast<char>(0xFF & (n >> 24)));
+    }
+    template<typename Sink>
+    static void write_long(long, Sink&, boost::mpl::false_)
+    {
+    }
+    template<typename Sink>
+    static void write_long(long n, Sink& next)
+    {
+        typedef typename category_of<Sink>::type category;
+        typedef is_convertible<category, output> can_write;
+        write_long(n, next, can_write());
+    }
+
+    void close_impl()
+    {
+        footer_.clear();
+        offset_ = 0;
+        flags_ = 0;
+    }
+
+    enum state_type {
+        f_header_done = 1,
+        f_body_done = f_header_done << 1,
+        f_footer_done = f_body_done << 1
+    };
+    std::string  header_;
+    std::string  footer_;
+    std::size_t  offset_;
+    int          flags_;
+};
+BOOST_IOSTREAMS_PIPABLE(basic_gzip_compressor, 1)
+
+typedef basic_gzip_compressor<> gzip_compressor;
+
+//------------------Definition of helper templates for decompression----------//
+
+namespace detail {
+
+// Processes gzip headers
+class BOOST_IOSTREAMS_DECL gzip_header {
+public:
+    gzip_header() { reset(); }
+
+    // Members for processing header data
+    void process(char c);
+    bool done() const { return state_ == s_done; }
+    void reset();
+
+    // Members for accessing header data
+    std::string file_name() const { return file_name_; }
+    std::string comment() const { return comment_; }
+    bool text() const { return (flags_ & gzip::flags::text) != 0; }
+    int os() const { return os_; }
+    std::time_t mtime() const { return mtime_; }
+private:
+    enum state_type {
+        s_id1       = 1,
+        s_id2       = s_id1 + 1,
+        s_cm        = s_id2 + 1,
+        s_flg       = s_cm + 1,
+        s_mtime     = s_flg + 1,
+        s_xfl       = s_mtime + 1,
+        s_os        = s_xfl + 1,
+        s_xlen      = s_os + 1,
+        s_extra     = s_xlen + 1,
+        s_name      = s_extra + 1,
+        s_comment   = s_name + 1,
+        s_hcrc      = s_comment + 1,
+        s_done      = s_hcrc + 1
+    };
+    std::string  file_name_;
+    std::string  comment_;
+    int          os_;
+    std::time_t  mtime_;
+    int          flags_;
+    int          state_;
+    int          offset_;  // Offset within fixed-length region.
+    int          xlen_;    // Bytes remaining in extra field.
+};
+
+// Processes gzip footers
+class BOOST_IOSTREAMS_DECL gzip_footer {
+public:
+    gzip_footer() { reset(); }
+    
+    // Members for processing footer data
+    void process(char c);
+    bool done() const { return state_ == s_done; }
+    void reset();
+    
+    // Members for accessing footer data
+    zlib::ulong crc() const { return crc_; }
+    zlib::ulong uncompressed_size() const { return isize_; }
+private:
+    enum state_type {
+        s_crc     = 1,
+        s_isize   = s_crc + 1,
+        s_done    = s_isize + 1
+    };
+    zlib::ulong  crc_;
+    zlib::ulong  isize_;
+    int          state_;
+    int          offset_; 
+};
+
+} // End namespace boost::iostreams::detail.
+
+//------------------Definition of basic_gzip_decompressor---------------------//
+
+//
+// Template name: basic_gzip_decompressor
+// Description: Model of InputFilter implementing compression in the
+//      gzip format.
+//
+template<typename Alloc = std::allocator<char> >
+class basic_gzip_decompressor : basic_zlib_decompressor<Alloc> {
+private:
+    typedef basic_zlib_decompressor<Alloc>   base_type;
+    typedef typename base_type::string_type  string_type;
+public:
+    typedef char char_type;
+    struct category
+        : dual_use,
+          filter_tag,
+          multichar_tag,
+          closable_tag
+        { };
+    basic_gzip_decompressor( int window_bits = gzip::default_window_bits,
+                             std::streamsize buffer_size = default_device_buffer_size );
+
+    template<typename Sink>
+    std::streamsize write(Sink& snk, const char_type* s, std::streamsize n)
+    {
+        std::streamsize result = 0;
+        while(result < n) {
+            if(state_ == s_start) {
+                state_ = s_header;
+                header_.reset();
+                footer_.reset();
+            }
+            if (state_ == s_header) {
+                int c = s[result++];
+                header_.process(c);
+                if (header_.done())
+                    state_ = s_body;
+            } else if (state_ == s_body) {
+                try {
+                    std::streamsize amt = 
+                        base_type::write(snk, s + result, n - result);
+                    result += amt;
+                    if (!this->eof()) {
+                        break;
+                    } else {
+                        state_ = s_footer;
+                    }
+                } catch (const zlib_error& e) {
+                    boost::throw_exception(gzip_error(e));
+                }
+            } else { // state_ == s_footer
+                if (footer_.done()) {
+                    if (footer_.crc() != this->crc())
+                        boost::throw_exception(gzip_error(gzip::bad_crc));
+
+                    base_type::close(snk, BOOST_IOS::out);
+                    state_ = s_start;
+                } else {
+                    int c = s[result++];
+                    footer_.process(c);
+                }
+            }
+        }
+        return result;
+    }
+
+    template<typename Source>
+    std::streamsize read(Source& src, char_type* s, std::streamsize n)
+    {
+        typedef char_traits<char>  traits_type;
+        std::streamsize            result = 0;
+        peekable_source<Source>    peek(src, putback_);
+        while (result < n && state_ != s_done) {
+            if (state_ == s_start) {
+                state_ = s_header;
+                header_.reset();
+                footer_.reset();
+            }
+            if (state_ == s_header) {
+                int c = boost::iostreams::get(peek);
+                if (traits_type::is_eof(c)) {
+                    boost::throw_exception(gzip_error(gzip::bad_header));
+                } else if (traits_type::would_block(c)) {
+                    break;
+                }
+                header_.process(c);
+                if (header_.done())
+                    state_ = s_body;
+            } else if (state_ == s_body) {
+                try {
+                    std::streamsize amt = 
+                        base_type::read(peek, s + result, n - result);
+                    if (amt != -1) {
+                        result += amt;
+                        if (amt < n - result)
+                            break;
+                    } else {
+                        peek.putback(this->unconsumed_input());
+                        state_ = s_footer;
+                    }
+                } catch (const zlib_error& e) {
+                    boost::throw_exception(gzip_error(e));
+                }
+            } else { // state_ == s_footer
+                int c = boost::iostreams::get(peek);
+                if (traits_type::is_eof(c)) {
+                    boost::throw_exception(gzip_error(gzip::bad_footer));
+                } else if (traits_type::would_block(c)) {
+                    break;
+                }
+                footer_.process(c);
+                if (footer_.done()) {
+                    if (footer_.crc() != this->crc())
+                        boost::throw_exception(gzip_error(gzip::bad_crc));
+                    c = boost::iostreams::get(peek);
+                    if (traits_type::is_eof(c)) {
+                        state_ = s_done;
+                    } else {
+                        peek.putback(c);
+                        base_type::close(peek, BOOST_IOS::in);
+                        state_ = s_start;
+                        header_.reset();
+                        footer_.reset();
+                    }
+                }
+            }
+        }
+        if (peek.has_unconsumed_input()) {
+            putback_ = peek.unconsumed_input();
+        } else {
+            putback_.clear();
+        }
+        return result != 0 || state_ != s_done ?
+            result :
+            -1;
+    }
+
+    template<typename Source>
+    void close(Source& src, BOOST_IOS::openmode m)
+    {
+        try {
+            base_type::close(src, m);
+        } catch (const zlib_error& e) {
+            state_ = s_start;
+            boost::throw_exception(gzip_error(e));
+        }
+        if (m == BOOST_IOS::out) {
+            if (state_ == s_start || state_ == s_header)
+                boost::throw_exception(gzip_error(gzip::bad_header));
+            else if (state_ == s_body)
+                boost::throw_exception(gzip_error(gzip::bad_footer));
+            else if (state_ == s_footer) {
+                if (!footer_.done())
+                    boost::throw_exception(gzip_error(gzip::bad_footer));
+                else if(footer_.crc() != this->crc())
+                    boost::throw_exception(gzip_error(gzip::bad_crc));
+            } else {
+                BOOST_ASSERT(!"Bad state");
+            }
+        }
+        state_ = s_start;
+    }
+
+    std::string file_name() const { return header_.file_name(); }
+    std::string comment() const { return header_.comment(); }
+    bool text() const { return header_.text(); }
+    int os() const { return header_.os(); }
+    std::time_t mtime() const { return header_.mtime(); }
+private:
+    static gzip_params make_params(int window_bits);
+
+    // Source adapter allowing an arbitrary character sequence to be put back.
+    template<typename Source>
+    struct peekable_source {
+        typedef char char_type;
+        struct category : source_tag, peekable_tag { };
+        explicit peekable_source(Source& src, const string_type& putback = "") 
+            : src_(src), putback_(putback), offset_(0)
+            { }
+        std::streamsize read(char* s, std::streamsize n)
+        {
+            std::streamsize result = 0;
+
+            // Copy characters from putback buffer
+            std::streamsize pbsize = 
+                static_cast<std::streamsize>(putback_.size());
+            if (offset_ < pbsize) {
+                result = (std::min)(n, pbsize - offset_);
+                BOOST_IOSTREAMS_CHAR_TRAITS(char)::copy(
+                    s, putback_.data() + offset_, result);
+                offset_ += result;
+                if (result == n)
+                    return result;
+            }
+
+            // Read characters from src_
+            std::streamsize amt = 
+                boost::iostreams::read(src_, s + result, n - result);
+            return amt != -1 ? 
+                result + amt : 
+                result ? result : -1;
+        }
+        bool putback(char c)
+        {
+            if (offset_) {
+                putback_[--offset_] = c;
+            } else {
+                boost::throw_exception(
+                    boost::iostreams::detail::bad_putback());
+            }
+            return true;
+        }
+        void putback(const string_type& s)
+        {
+            putback_.replace(0, offset_, s);
+            offset_ = 0;
+        }
+
+        // Returns true if some characters have been putback but not re-read.
+        bool has_unconsumed_input() const 
+        {
+            return offset_ < static_cast<std::streamsize>(putback_.size());
+        }
+
+        // Returns the sequence of characters that have been put back but not re-read.
+        string_type unconsumed_input() const
+        {
+            return string_type(putback_, offset_, putback_.size() - offset_);
+        }
+        Source&          src_;
+        string_type      putback_;
+        std::streamsize  offset_;
+    };
+
+    enum state_type {
+        s_start   = 1,
+        s_header  = s_start + 1,
+        s_body    = s_header + 1,
+        s_footer  = s_body + 1,
+        s_done    = s_footer + 1
+    };
+    detail::gzip_header  header_;
+    detail::gzip_footer  footer_;
+    string_type          putback_;
+    int                  state_;
+};
+BOOST_IOSTREAMS_PIPABLE(basic_gzip_decompressor, 1)
+
+typedef basic_gzip_decompressor<> gzip_decompressor;
+
+//------------------Implementation of gzip_compressor-------------------------//
+
+template<typename Alloc>
+basic_gzip_compressor<Alloc>::basic_gzip_compressor
+    (const gzip_params& p, std::streamsize buffer_size)
+    : base_type(normalize_params(p), buffer_size),
+      offset_(0), flags_(0)
+{
+    // Calculate gzip header.
+    bool has_name = !p.file_name.empty();
+    bool has_comment = !p.comment.empty();
+
+    std::string::size_type length =
+        10 +
+        (has_name ? p.file_name.size() + 1 : 0) +
+        (has_comment ? p.comment.size() + 1 : 0);
+        // + 2; // Header crc confuses gunzip.
+    int flags =
+        //gzip::flags::header_crc +
+        (has_name ? gzip::flags::name : 0) +
+        (has_comment ? gzip::flags::comment : 0);
+    int extra_flags =
+        ( p.level == zlib::best_compression ?
+              gzip::extra_flags::best_compression :
+              0 ) +
+        ( p.level == zlib::best_speed ?
+              gzip::extra_flags::best_speed :
+              0 );
+    header_.reserve(length);
+    header_ += gzip::magic::id1;                         // ID1.
+    header_ += static_cast<char>(gzip::magic::id2);      // ID2.
+    header_ += gzip::method::deflate;                    // CM.
+    header_ += static_cast<char>(flags);                 // FLG.
+    header_ += static_cast<char>(0xFF & p.mtime);        // MTIME.
+    header_ += static_cast<char>(0xFF & (p.mtime >> 8));
+    header_ += static_cast<char>(0xFF & (p.mtime >> 16));
+    header_ += static_cast<char>(0xFF & (p.mtime >> 24));
+    header_ += static_cast<char>(extra_flags);           // XFL.
+    header_ += static_cast<char>(gzip::os_unknown);      // OS.
+    if (has_name) {
+        header_ += p.file_name;
+        header_ += '\0';
+    }
+    if (has_comment) {
+        header_ += p.comment;
+        header_ += '\0';
+    }
+}
+
+template<typename Alloc>
+gzip_params basic_gzip_compressor<Alloc>::normalize_params(gzip_params p)
+{
+    p.noheader = true;
+    p.calculate_crc = true;
+    return p;
+}
+
+template<typename Alloc>
+void basic_gzip_compressor<Alloc>::prepare_footer()
+{
+    boost::iostreams::back_insert_device<std::string> out(footer_);
+    write_long(this->crc(), out);
+    write_long(this->total_in(), out);
+    flags_ |= f_body_done;
+    offset_ = 0;
+}
+
+template<typename Alloc>
+std::streamsize basic_gzip_compressor<Alloc>::read_string
+    (char* s, std::streamsize n, std::string& str)
+{
+    std::streamsize avail =
+        static_cast<std::streamsize>(str.size() - offset_);
+    std::streamsize amt = (std::min)(avail, n);
+    std::copy( str.data() + offset_,
+               str.data() + offset_ + amt,
+               s );
+    offset_ += amt;
+    if ( !(flags_ & f_header_done) &&
+         offset_ == static_cast<std::size_t>(str.size()) )
+    {
+        flags_ |= f_header_done;
+    }
+    return amt;
+}
+
+//------------------Implementation of gzip_decompressor-----------------------//
+
+template<typename Alloc>
+basic_gzip_decompressor<Alloc>::basic_gzip_decompressor
+    (int window_bits, std::streamsize buffer_size)
+    : base_type(make_params(window_bits), buffer_size),
+      state_(s_start)
+    { }
+
+template<typename Alloc>
+gzip_params basic_gzip_decompressor<Alloc>::make_params(int window_bits)
+{
+    gzip_params p;
+    p.window_bits = window_bits;
+    p.noheader = true;
+    p.calculate_crc = true;
+    return p;
+}
+
+//----------------------------------------------------------------------------//
+
+} } // End namespaces iostreams, boost.
+
+#if defined(BOOST_MSVC)
+# pragma warning(pop)
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_GZIP_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/filter/lzma.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/filter/lzma.hpp
new file mode 100644
index 0000000000..94cd2b3b54
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/filter/lzma.hpp
@@ -0,0 +1,372 @@
+// (C) Copyright Milan Svoboda 2008.
+// Originally developed under the fusecompress project.
+// 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/iostreams for documentation.
+
+// Note: custom allocators are not supported on VC6, since that compiler
+// had trouble finding the function lzma_base::do_init.
+
+#ifndef BOOST_IOSTREAMS_LZMA_HPP_INCLUDED
+#define BOOST_IOSTREAMS_LZMA_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <cassert>
+#include <iosfwd>            // streamsize.
+#include <memory>            // allocator, bad_alloc.
+#include <new>
+#include <boost/config.hpp>  // MSVC, STATIC_CONSTANT, DEDUCED_TYPENAME, DINKUM.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/constants.hpp>   // buffer size.
+#include <boost/iostreams/detail/config/auto_link.hpp>
+#include <boost/iostreams/detail/config/dyn_link.hpp>
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#include <boost/iostreams/detail/ios.hpp>  // failure, streamsize.
+#include <boost/iostreams/filter/symmetric.hpp>
+#include <boost/iostreams/pipeline.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+// Must come last.
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable:4251 4231 4660)         // Dependencies not exported.
+#endif
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost { namespace iostreams {
+
+namespace lzma {
+
+typedef void* (*alloc_func)(void*, size_t, size_t);
+typedef void (*free_func)(void*, void*);
+
+                    // Compression levels
+
+BOOST_IOSTREAMS_DECL extern const uint32_t no_compression;
+BOOST_IOSTREAMS_DECL extern const uint32_t best_speed;
+BOOST_IOSTREAMS_DECL extern const uint32_t best_compression;
+BOOST_IOSTREAMS_DECL extern const uint32_t default_compression;
+
+                    // Status codes
+
+BOOST_IOSTREAMS_DECL extern const int okay;
+BOOST_IOSTREAMS_DECL extern const int stream_end;
+BOOST_IOSTREAMS_DECL extern const int unsupported_check;
+BOOST_IOSTREAMS_DECL extern const int mem_error;
+BOOST_IOSTREAMS_DECL extern const int options_error;
+BOOST_IOSTREAMS_DECL extern const int data_error;
+BOOST_IOSTREAMS_DECL extern const int buf_error;
+BOOST_IOSTREAMS_DECL extern const int prog_error;
+
+                    // Flush codes
+
+BOOST_IOSTREAMS_DECL extern const int finish;
+BOOST_IOSTREAMS_DECL extern const int full_flush;
+BOOST_IOSTREAMS_DECL extern const int sync_flush;
+BOOST_IOSTREAMS_DECL extern const int run;
+
+                    // Code for current OS
+
+                    // Null pointer constant.
+
+const int null                               = 0;
+
+                    // Default values
+
+} // End namespace lzma.
+
+//
+// Class name: lzma_params.
+// Description: Encapsulates the parameters passed to lzmadec_init
+//      to customize compression and decompression.
+//
+struct lzma_params {
+
+    // Non-explicit constructor.
+    lzma_params( uint32_t level = lzma::default_compression )
+        : level(level)
+        { }
+    uint32_t level;
+};
+
+//
+// Class name: lzma_error.
+// Description: Subclass of std::ios::failure thrown to indicate
+//     lzma errors other than out-of-memory conditions.
+//
+class BOOST_IOSTREAMS_DECL lzma_error : public BOOST_IOSTREAMS_FAILURE {
+public:
+    explicit lzma_error(int error);
+    int error() const { return error_; }
+    static void check BOOST_PREVENT_MACRO_SUBSTITUTION(int error);
+private:
+    int error_;
+};
+
+namespace detail {
+
+template<typename Alloc>
+struct lzma_allocator_traits {
+#ifndef BOOST_NO_STD_ALLOCATOR
+#if defined(BOOST_NO_CXX11_ALLOCATOR)
+    typedef typename Alloc::template rebind<char>::other type;
+#else
+    typedef typename std::allocator_traits<Alloc>::template rebind_alloc<char> type;
+#endif
+#else
+    typedef std::allocator<char> type;
+#endif
+};
+
+template< typename Alloc,
+          typename Base = // VC6 workaround (C2516)
+              BOOST_DEDUCED_TYPENAME lzma_allocator_traits<Alloc>::type >
+struct lzma_allocator : private Base {
+private:
+#if defined(BOOST_NO_CXX11_ALLOCATOR) || defined(BOOST_NO_STD_ALLOCATOR)
+    typedef typename Base::size_type size_type;
+#else
+    typedef typename std::allocator_traits<Base>::size_type size_type;
+#endif
+public:
+    BOOST_STATIC_CONSTANT(bool, custom =
+        (!is_same<std::allocator<char>, Base>::value));
+    typedef typename lzma_allocator_traits<Alloc>::type allocator_type;
+    static void* allocate(void* self, size_t items, size_t size);
+    static void deallocate(void* self, void* address);
+};
+
+class BOOST_IOSTREAMS_DECL lzma_base {
+public:
+    typedef char char_type;
+protected:
+    lzma_base();
+    ~lzma_base();
+    void* stream() { return stream_; }
+    template<typename Alloc>
+    void init( const lzma_params& p,
+               bool compress,
+               lzma_allocator<Alloc>& zalloc )
+        {
+            bool custom = lzma_allocator<Alloc>::custom;
+            do_init( p, compress,
+                     custom ? lzma_allocator<Alloc>::allocate : 0,
+                     custom ? lzma_allocator<Alloc>::deallocate : 0,
+                     &zalloc );
+        }
+    void before( const char*& src_begin, const char* src_end,
+                 char*& dest_begin, char* dest_end );
+    void after( const char*& src_begin, char*& dest_begin,
+                bool compress );
+    int deflate(int action);
+    int inflate(int action);
+    void reset(bool compress, bool realloc);
+private:
+    void do_init( const lzma_params& p, bool compress,
+                  lzma::alloc_func,
+                  lzma::free_func,
+                  void* derived );
+    void*         stream_;         // Actual type: lzmadec_stream*.
+    uint32_t level;
+};
+
+//
+// Template name: lzma_compressor_impl
+// Description: Model of C-Style Filter implementing compression by
+//      delegating to the lzma function deflate.
+//
+template<typename Alloc = std::allocator<char> >
+class lzma_compressor_impl : public lzma_base, public lzma_allocator<Alloc> {
+public:
+    lzma_compressor_impl(const lzma_params& = lzma::default_compression);
+    ~lzma_compressor_impl();
+    bool filter( const char*& src_begin, const char* src_end,
+                 char*& dest_begin, char* dest_end, bool flush );
+    void close();
+};
+
+//
+// Template name: lzma_compressor_impl
+// Description: Model of C-Style Filte implementing decompression by
+//      delegating to the lzma function inflate.
+//
+template<typename Alloc = std::allocator<char> >
+class lzma_decompressor_impl : public lzma_base, public lzma_allocator<Alloc> {
+public:
+    lzma_decompressor_impl(const lzma_params&);
+    lzma_decompressor_impl();
+    ~lzma_decompressor_impl();
+    bool filter( const char*& begin_in, const char* end_in,
+                 char*& begin_out, char* end_out, bool flush );
+    void close();
+};
+
+} // End namespace detail.
+
+//
+// Template name: lzma_compressor
+// Description: Model of InputFilter and OutputFilter implementing
+//      compression using lzma.
+//
+template<typename Alloc = std::allocator<char> >
+struct basic_lzma_compressor
+    : symmetric_filter<detail::lzma_compressor_impl<Alloc>, Alloc>
+{
+private:
+    typedef detail::lzma_compressor_impl<Alloc> impl_type;
+    typedef symmetric_filter<impl_type, Alloc>  base_type;
+public:
+    typedef typename base_type::char_type               char_type;
+    typedef typename base_type::category                category;
+    basic_lzma_compressor( const lzma_params& = lzma::default_compression,
+                           std::streamsize buffer_size = default_device_buffer_size );
+};
+BOOST_IOSTREAMS_PIPABLE(basic_lzma_compressor, 1)
+
+typedef basic_lzma_compressor<> lzma_compressor;
+
+//
+// Template name: lzma_decompressor
+// Description: Model of InputFilter and OutputFilter implementing
+//      decompression using lzma.
+//
+template<typename Alloc = std::allocator<char> >
+struct basic_lzma_decompressor
+    : symmetric_filter<detail::lzma_decompressor_impl<Alloc>, Alloc>
+{
+private:
+    typedef detail::lzma_decompressor_impl<Alloc> impl_type;
+    typedef symmetric_filter<impl_type, Alloc>    base_type;
+public:
+    typedef typename base_type::char_type               char_type;
+    typedef typename base_type::category                category;
+    basic_lzma_decompressor( std::streamsize buffer_size = default_device_buffer_size );
+    basic_lzma_decompressor( const lzma_params& p,
+                             std::streamsize buffer_size = default_device_buffer_size );
+};
+BOOST_IOSTREAMS_PIPABLE(basic_lzma_decompressor, 1)
+
+typedef basic_lzma_decompressor<> lzma_decompressor;
+
+//----------------------------------------------------------------------------//
+
+//------------------Implementation of lzma_allocator--------------------------//
+
+namespace detail {
+
+template<typename Alloc, typename Base>
+void* lzma_allocator<Alloc, Base>::allocate
+    (void* self, size_t items, size_t size)
+{
+    size_type len = items * size;
+    char* ptr =
+        static_cast<allocator_type*>(self)->allocate
+            (len + sizeof(size_type)
+            #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+                , (char*)0
+            #endif
+            );
+    *reinterpret_cast<size_type*>(ptr) = len;
+    return ptr + sizeof(size_type);
+}
+
+template<typename Alloc, typename Base>
+void lzma_allocator<Alloc, Base>::deallocate(void* self, void* address)
+{
+    char* ptr = reinterpret_cast<char*>(address) - sizeof(size_type);
+    size_type len = *reinterpret_cast<size_type*>(ptr) + sizeof(size_type);
+    static_cast<allocator_type*>(self)->deallocate(ptr, len);
+}
+
+//------------------Implementation of lzma_compressor_impl--------------------//
+
+template<typename Alloc>
+lzma_compressor_impl<Alloc>::lzma_compressor_impl(const lzma_params& p)
+{ init(p, true, static_cast<lzma_allocator<Alloc>&>(*this)); }
+
+template<typename Alloc>
+lzma_compressor_impl<Alloc>::~lzma_compressor_impl()
+{ reset(true, false); }
+
+template<typename Alloc>
+bool lzma_compressor_impl<Alloc>::filter
+    ( const char*& src_begin, const char* src_end,
+      char*& dest_begin, char* dest_end, bool flush )
+{
+    before(src_begin, src_end, dest_begin, dest_end);
+    int result = deflate(flush ? lzma::finish : lzma::run);
+    after(src_begin, dest_begin, true);
+    lzma_error::check BOOST_PREVENT_MACRO_SUBSTITUTION(result);
+    return result != lzma::stream_end;
+}
+
+template<typename Alloc>
+void lzma_compressor_impl<Alloc>::close() { reset(true, true); }
+
+//------------------Implementation of lzma_decompressor_impl------------------//
+
+template<typename Alloc>
+lzma_decompressor_impl<Alloc>::lzma_decompressor_impl(const lzma_params& p)
+{ init(p, false, static_cast<lzma_allocator<Alloc>&>(*this)); }
+
+template<typename Alloc>
+lzma_decompressor_impl<Alloc>::~lzma_decompressor_impl()
+{ reset(false, false); }
+
+template<typename Alloc>
+lzma_decompressor_impl<Alloc>::lzma_decompressor_impl()
+{
+    lzma_params p;
+    init(p, false, static_cast<lzma_allocator<Alloc>&>(*this));
+}
+
+template<typename Alloc>
+bool lzma_decompressor_impl<Alloc>::filter
+    ( const char*& src_begin, const char* src_end,
+      char*& dest_begin, char* dest_end, bool flush )
+{
+    before(src_begin, src_end, dest_begin, dest_end);
+    int result = inflate(flush ? lzma::finish : lzma::run);
+    after(src_begin, dest_begin, false);
+    lzma_error::check BOOST_PREVENT_MACRO_SUBSTITUTION(result);
+    return result != lzma::stream_end;
+}
+
+template<typename Alloc>
+void lzma_decompressor_impl<Alloc>::close() { reset(false, true); }
+
+} // End namespace detail.
+
+//------------------Implementation of lzma_compressor-----------------------//
+
+template<typename Alloc>
+basic_lzma_compressor<Alloc>::basic_lzma_compressor
+    (const lzma_params& p, std::streamsize buffer_size)
+    : base_type(buffer_size, p) { }
+
+//------------------Implementation of lzma_decompressor-----------------------//
+
+template<typename Alloc>
+basic_lzma_decompressor<Alloc>::basic_lzma_decompressor
+    (std::streamsize buffer_size)
+    : base_type(buffer_size) { }
+
+template<typename Alloc>
+basic_lzma_decompressor<Alloc>::basic_lzma_decompressor
+    (const lzma_params& p, std::streamsize buffer_size)
+    : base_type(buffer_size, p) { }
+
+//----------------------------------------------------------------------------//
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/config/abi_suffix.hpp> // Pops abi_suffix.hpp pragmas.
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_LZMA_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/filter/symmetric.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/filter/symmetric.hpp
new file mode 100644
index 0000000000..f18089f4fb
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/filter/symmetric.hpp
@@ -0,0 +1,311 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Contains the definitions of the class templates symmetric_filter,
+// which models DualUseFilter based on a model of the Symmetric Filter.
+
+//
+// Roughly, a Symmetric Filter is a class type with the following interface:
+//
+//   struct symmetric_filter {
+//       typedef xxx char_type;
+//
+//       bool filter( const char*& begin_in, const char* end_in,
+//                    char*& begin_out, char* end_out, bool flush )
+//       {
+//          // Consume as many characters as possible from the interval
+//          // [begin_in, end_in), without exhausting the output range
+//          // [begin_out, end_out). If flush is true, write as mush output
+//          // as possible. 
+//          // A return value of true indicates that filter should be called 
+//          // again. More precisely, if flush is false, a return value of 
+//          // false indicates that the natural end of stream has been reached
+//          // and that all filtered data has been forwarded; if flush is
+//          // true, a return value of false indicates that all filtered data 
+//          // has been forwarded.
+//       }
+//       void close() { /* Reset filter's state. */ }
+//   };
+//
+// Symmetric Filter filters need not be CopyConstructable.
+//
+
+#ifndef BOOST_IOSTREAMS_SYMMETRIC_FILTER_HPP_INCLUDED
+#define BOOST_IOSTREAMS_SYMMETRIC_FILTER_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/assert.hpp>
+#include <memory>                               // allocator.
+#include <boost/config.hpp>                     // BOOST_DEDUCED_TYPENAME.
+#include <boost/iostreams/char_traits.hpp>
+#include <boost/iostreams/constants.hpp>        // buffer size.
+#include <boost/iostreams/detail/buffer.hpp>
+#include <boost/iostreams/detail/char_traits.hpp>
+#include <boost/iostreams/detail/config/limits.hpp>
+#include <boost/iostreams/detail/ios.hpp>  // streamsize.
+#include <boost/iostreams/detail/template_params.hpp>
+#include <boost/iostreams/traits.hpp>
+#include <boost/iostreams/operations.hpp>       // read, write.
+#include <boost/iostreams/pipeline.hpp>
+#include <boost/preprocessor/iteration/local.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/shared_ptr.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>  // MSVC.
+
+namespace boost { namespace iostreams {
+
+template< typename SymmetricFilter,
+          typename Alloc =
+              std::allocator<
+                  BOOST_DEDUCED_TYPENAME char_type_of<SymmetricFilter>::type
+              > >
+class symmetric_filter {
+public:
+    typedef typename char_type_of<SymmetricFilter>::type      char_type;
+    typedef BOOST_IOSTREAMS_CHAR_TRAITS(char_type)            traits_type;
+    typedef std::basic_string<char_type, traits_type, Alloc>  string_type;
+    struct category
+        : dual_use,
+          filter_tag,
+          multichar_tag,
+          closable_tag
+        { };
+
+    // Expands to a sequence of ctors which forward to impl.
+    #define BOOST_PP_LOCAL_MACRO(n) \
+        BOOST_IOSTREAMS_TEMPLATE_PARAMS(n, T) \
+        explicit symmetric_filter( \
+              std::streamsize buffer_size BOOST_PP_COMMA_IF(n) \
+              BOOST_PP_ENUM_BINARY_PARAMS(n, const T, &t) ) \
+            : pimpl_(new impl(buffer_size BOOST_PP_COMMA_IF(n) \
+                     BOOST_PP_ENUM_PARAMS(n, t))) \
+            { BOOST_ASSERT(buffer_size > 0); } \
+        /**/
+    #define BOOST_PP_LOCAL_LIMITS (0, BOOST_IOSTREAMS_MAX_FORWARDING_ARITY)
+    #include BOOST_PP_LOCAL_ITERATE()
+    #undef BOOST_PP_LOCAL_MACRO
+
+    template<typename Source>
+    std::streamsize read(Source& src, char_type* s, std::streamsize n)
+    {
+        using namespace std;
+        if (!(state() & f_read))
+            begin_read();
+
+        buffer_type&  buf = pimpl_->buf_;
+        int           status = (state() & f_eof) != 0 ? f_eof : f_good;
+        char_type    *next_s = s,
+                     *end_s = s + n;
+        while (true)
+        {
+            // Invoke filter if there are unconsumed characters in buffer or if
+            // filter must be flushed.
+            bool flush = status == f_eof;
+            if (buf.ptr() != buf.eptr() || flush) {
+                const char_type* next = buf.ptr();
+                bool done =
+                    !filter().filter(next, buf.eptr(), next_s, end_s, flush);
+                buf.ptr() = buf.data() + (next - buf.data());
+                if (done)
+                    return detail::check_eof(
+                               static_cast<std::streamsize>(next_s - s)
+                           );
+            }
+
+            // If no more characters are available without blocking, or
+            // if read request has been satisfied, return.
+            if ( (status == f_would_block && buf.ptr() == buf.eptr()) ||
+                 next_s == end_s )
+            {
+                return static_cast<std::streamsize>(next_s - s);
+            }
+
+            // Fill buffer.
+            if (status == f_good)
+                status = fill(src);
+        }
+    }
+
+    template<typename Sink>
+    std::streamsize write(Sink& snk, const char_type* s, std::streamsize n)
+    {
+        if (!(state() & f_write))
+            begin_write();
+
+        buffer_type&     buf = pimpl_->buf_;
+        const char_type *next_s, *end_s;
+        for (next_s = s, end_s = s + n; next_s != end_s; ) {
+            if (buf.ptr() == buf.eptr() && !flush(snk))
+                break;
+            if(!filter().filter(next_s, end_s, buf.ptr(), buf.eptr(), false)) {
+                flush(snk);
+                break;
+            }
+        }
+        return static_cast<std::streamsize>(next_s - s);
+    }
+
+    template<typename Sink>
+    void close(Sink& snk, BOOST_IOS::openmode mode)
+    {
+        if (mode == BOOST_IOS::out) {
+
+            if (!(state() & f_write))
+                begin_write();
+
+            // Repeatedly invoke filter() with no input.
+            try {
+                buffer_type&     buf = pimpl_->buf_;
+                char_type        dummy;
+                const char_type* end = &dummy;
+                bool             again = true;
+                while (again) {
+                    if (buf.ptr() != buf.eptr())
+                        again = filter().filter( end, end, buf.ptr(),
+                                                 buf.eptr(), true );
+                    flush(snk);
+                }
+            } catch (...) {
+                try { close_impl(); } catch (...) { }
+                throw;
+            }
+            close_impl();
+        } else {
+            close_impl();
+        }
+    }
+    SymmetricFilter& filter() { return *pimpl_; }
+    string_type unconsumed_input() const;
+
+// Give impl access to buffer_type on Tru64
+#if !BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042)) 
+    private:
+#endif
+    typedef detail::buffer<char_type, Alloc> buffer_type;
+private:
+    buffer_type& buf() { return pimpl_->buf_; }
+    const buffer_type& buf() const { return pimpl_->buf_; }
+    int& state() { return pimpl_->state_; }
+    void begin_read();
+    void begin_write();
+
+    template<typename Source>
+    int fill(Source& src)
+    {
+        std::streamsize amt = iostreams::read(src, buf().data(), buf().size());
+        if (amt == -1) {
+            state() |= f_eof;
+            return f_eof;
+        }
+        buf().set(0, amt);
+        return amt != 0 ? f_good : f_would_block;
+    }
+
+    // Attempts to write the contents of the buffer the given Sink.
+    // Returns true if at least on character was written.
+    template<typename Sink>
+    bool flush(Sink& snk)
+    {
+        typedef typename iostreams::category_of<Sink>::type  category;
+        typedef is_convertible<category, output>             can_write;
+        return flush(snk, can_write());
+    }
+
+    template<typename Sink>
+    bool flush(Sink& snk, mpl::true_)
+    {
+        std::streamsize amt =
+            static_cast<std::streamsize>(buf().ptr() - buf().data());
+        std::streamsize result =
+            boost::iostreams::write(snk, buf().data(), amt);
+        if (result < amt && result > 0)
+            traits_type::move(buf().data(), buf().data() + result, amt - result);
+        buf().set(amt - result, buf().size());
+        return result != 0;
+    }
+
+    template<typename Sink>
+    bool flush(Sink&, mpl::false_) { return true;}
+
+    void close_impl();
+
+    enum flag_type {
+        f_read   = 1,
+        f_write  = f_read << 1,
+        f_eof    = f_write << 1,
+        f_good,
+        f_would_block
+    };
+
+    struct impl : SymmetricFilter {
+
+    // Expands to a sequence of ctors which forward to SymmetricFilter.
+    #define BOOST_PP_LOCAL_MACRO(n) \
+        BOOST_IOSTREAMS_TEMPLATE_PARAMS(n, T) \
+        impl( std::streamsize buffer_size BOOST_PP_COMMA_IF(n) \
+              BOOST_PP_ENUM_BINARY_PARAMS(n, const T, &t) ) \
+            : SymmetricFilter(BOOST_PP_ENUM_PARAMS(n, t)), \
+              buf_(buffer_size), state_(0) \
+            { } \
+        /**/
+    #define BOOST_PP_LOCAL_LIMITS (0, BOOST_IOSTREAMS_MAX_FORWARDING_ARITY)
+    #include BOOST_PP_LOCAL_ITERATE()
+    #undef BOOST_PP_LOCAL_MACRO
+
+        buffer_type  buf_;
+        int          state_;
+    };
+
+    shared_ptr<impl> pimpl_;
+};
+BOOST_IOSTREAMS_PIPABLE(symmetric_filter, 2)
+
+//------------------Implementation of symmetric_filter----------------//
+
+template<typename SymmetricFilter, typename Alloc>
+void symmetric_filter<SymmetricFilter, Alloc>::begin_read()
+{
+    BOOST_ASSERT(!(state() & f_write));
+    state() |= f_read;
+    buf().set(0, 0);
+}
+
+template<typename SymmetricFilter, typename Alloc>
+void symmetric_filter<SymmetricFilter, Alloc>::begin_write()
+{
+    BOOST_ASSERT(!(state() & f_read));
+    state() |= f_write;
+    buf().set(0, buf().size());
+}
+
+template<typename SymmetricFilter, typename Alloc>
+void symmetric_filter<SymmetricFilter, Alloc>::close_impl()
+{
+    state() = 0;
+    buf().set(0, 0);
+    filter().close();
+}
+
+template<typename SymmetricFilter, typename Alloc>
+typename symmetric_filter<SymmetricFilter, Alloc>::string_type
+symmetric_filter<SymmetricFilter, Alloc>::unconsumed_input() const
+{ return string_type(buf().ptr(), buf().eptr()); }
+
+//----------------------------------------------------------------------------//
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp>  // MSVC.
+
+#endif // #ifndef BOOST_IOSTREAMS_SYMMETRIC_FILTER_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/filter/zlib.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/filter/zlib.hpp
new file mode 100644
index 0000000000..e57870a510
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/filter/zlib.hpp
@@ -0,0 +1,431 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Note: custom allocators are not supported on VC6, since that compiler
+// had trouble finding the function zlib_base::do_init.
+
+#ifndef BOOST_IOSTREAMS_ZLIB_HPP_INCLUDED
+#define BOOST_IOSTREAMS_ZLIB_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <cassert>                            
+#include <iosfwd>            // streamsize.                 
+#include <memory>            // allocator, bad_alloc.
+#include <new>          
+#include <boost/config.hpp>  // MSVC, STATIC_CONSTANT, DEDUCED_TYPENAME, DINKUM.
+#include <boost/cstdint.hpp> // uint*_t
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/constants.hpp>   // buffer size.
+#include <boost/iostreams/detail/config/auto_link.hpp>
+#include <boost/iostreams/detail/config/dyn_link.hpp>
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#include <boost/iostreams/detail/config/zlib.hpp>
+#include <boost/iostreams/detail/ios.hpp>  // failure, streamsize.
+#include <boost/iostreams/filter/symmetric.hpp>                
+#include <boost/iostreams/pipeline.hpp>                
+#include <boost/type_traits/is_same.hpp>
+
+// Must come last.
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable:4251 4275 4231 4660)         // Dependencies not exported.
+#endif
+#include <boost/config/abi_prefix.hpp>           
+
+namespace boost { namespace iostreams {
+
+namespace zlib {
+                    // Typedefs
+
+typedef uint32_t uint;
+typedef uint8_t byte;
+typedef uint32_t ulong;
+
+// Prefix 'x' prevents symbols from being redefined when Z_PREFIX is defined
+typedef void* (*xalloc_func)(void*, zlib::uint, zlib::uint);
+typedef void (*xfree_func)(void*, void*);
+
+                    // Compression levels
+
+BOOST_IOSTREAMS_DECL extern const int no_compression;
+BOOST_IOSTREAMS_DECL extern const int best_speed;
+BOOST_IOSTREAMS_DECL extern const int best_compression;
+BOOST_IOSTREAMS_DECL extern const int default_compression;
+
+                    // Compression methods
+
+BOOST_IOSTREAMS_DECL extern const int deflated;
+
+                    // Compression strategies
+
+BOOST_IOSTREAMS_DECL extern const int default_strategy;
+BOOST_IOSTREAMS_DECL extern const int filtered;
+BOOST_IOSTREAMS_DECL extern const int huffman_only;
+
+                    // Status codes
+
+BOOST_IOSTREAMS_DECL extern const int okay;
+BOOST_IOSTREAMS_DECL extern const int stream_end;
+BOOST_IOSTREAMS_DECL extern const int stream_error;
+BOOST_IOSTREAMS_DECL extern const int version_error;
+BOOST_IOSTREAMS_DECL extern const int data_error;
+BOOST_IOSTREAMS_DECL extern const int mem_error;
+BOOST_IOSTREAMS_DECL extern const int buf_error;
+
+                    // Flush codes
+
+BOOST_IOSTREAMS_DECL extern const int finish;
+BOOST_IOSTREAMS_DECL extern const int no_flush;
+BOOST_IOSTREAMS_DECL extern const int sync_flush;
+
+                    // Code for current OS
+
+//BOOST_IOSTREAMS_DECL extern const int os_code;
+
+                    // Null pointer constant.
+
+const int null                               = 0;
+
+                    // Default values
+
+const int default_window_bits                = 15;
+const int default_mem_level                  = 8;
+const bool default_crc                       = false;
+const bool default_noheader                  = false;
+
+} // End namespace zlib. 
+
+//
+// Class name: zlib_params.
+// Description: Encapsulates the parameters passed to deflateInit2
+//      and inflateInit2 to customize compression and decompression.
+//
+struct zlib_params {
+
+    // Non-explicit constructor.
+    zlib_params( int level_          = zlib::default_compression,
+                 int method_         = zlib::deflated,
+                 int window_bits_    = zlib::default_window_bits, 
+                 int mem_level_      = zlib::default_mem_level, 
+                 int strategy_       = zlib::default_strategy,
+                 bool noheader_      = zlib::default_noheader,
+                 bool calculate_crc_ = zlib::default_crc )
+        : level(level_), method(method_), window_bits(window_bits_),
+          mem_level(mem_level_), strategy(strategy_),  
+          noheader(noheader_), calculate_crc(calculate_crc_)
+        { }
+    int level;
+    int method;
+    int window_bits;
+    int mem_level;
+    int strategy;
+    bool noheader;
+    bool calculate_crc;
+};
+
+//
+// Class name: zlib_error.
+// Description: Subclass of std::ios::failure thrown to indicate
+//     zlib errors other than out-of-memory conditions.
+//
+class BOOST_IOSTREAMS_DECL zlib_error : public BOOST_IOSTREAMS_FAILURE {
+public:
+    explicit zlib_error(int error);
+    int error() const { return error_; }
+    static void check BOOST_PREVENT_MACRO_SUBSTITUTION(int error);
+private:
+    int error_;
+};
+
+namespace detail {
+
+template<typename Alloc>
+struct zlib_allocator_traits {
+#ifndef BOOST_NO_STD_ALLOCATOR
+#if defined(BOOST_NO_CXX11_ALLOCATOR)
+    typedef typename Alloc::template rebind<char>::other type;
+#else
+    typedef typename std::allocator_traits<Alloc>::template rebind_alloc<char> type;
+#endif
+#else
+    typedef std::allocator<char> type;
+#endif
+};
+
+template< typename Alloc,
+          typename Base = // VC6 workaround (C2516)
+              BOOST_DEDUCED_TYPENAME zlib_allocator_traits<Alloc>::type >
+struct zlib_allocator : private Base {
+private:
+#if defined(BOOST_NO_CXX11_ALLOCATOR) || defined(BOOST_NO_STD_ALLOCATOR)
+    typedef typename Base::size_type size_type;
+#else
+    typedef typename std::allocator_traits<Base>::size_type size_type;
+#endif
+public:
+    BOOST_STATIC_CONSTANT(bool, custom = 
+        (!is_same<std::allocator<char>, Base>::value));
+    typedef typename zlib_allocator_traits<Alloc>::type allocator_type;
+    static void* allocate(void* self, zlib::uint items, zlib::uint size);
+    static void deallocate(void* self, void* address);
+};
+
+class BOOST_IOSTREAMS_DECL zlib_base { 
+public:
+    typedef char char_type;
+protected:
+    zlib_base();
+    ~zlib_base();
+    void* stream() { return stream_; }
+    template<typename Alloc> 
+    void init( const zlib_params& p, 
+               bool compress,
+               zlib_allocator<Alloc>& zalloc )
+        {
+            bool custom = zlib_allocator<Alloc>::custom;
+            do_init( p, compress,
+                     custom ? zlib_allocator<Alloc>::allocate : 0,
+                     custom ? zlib_allocator<Alloc>::deallocate : 0,
+                     &zalloc );
+        }
+    void before( const char*& src_begin, const char* src_end,
+                 char*& dest_begin, char* dest_end );
+    void after( const char*& src_begin, char*& dest_begin, 
+                bool compress );
+    int xdeflate(int flush);  // Prefix 'x' prevents symbols from being 
+    int xinflate(int flush);  // redefined when Z_PREFIX is defined
+    void reset(bool compress, bool realloc);
+public:
+    zlib::ulong crc() const { return crc_; }
+    int total_in() const { return total_in_; }
+    int total_out() const { return total_out_; }
+private:
+    void do_init( const zlib_params& p, bool compress, 
+                  zlib::xalloc_func,
+                  zlib::xfree_func, 
+                  void* derived );
+    void*        stream_;         // Actual type: z_stream*.
+    bool         calculate_crc_;
+    zlib::ulong  crc_;
+    zlib::ulong  crc_imp_;
+    int          total_in_;
+    int          total_out_;
+};
+
+//
+// Template name: zlib_compressor_impl
+// Description: Model of C-Style Filte implementing compression by
+//      delegating to the zlib function deflate.
+//
+template<typename Alloc = std::allocator<char> >
+class zlib_compressor_impl : public zlib_base, public zlib_allocator<Alloc> { 
+public: 
+    zlib_compressor_impl(const zlib_params& = zlib::default_compression);
+    ~zlib_compressor_impl();
+    bool filter( const char*& src_begin, const char* src_end,
+                 char*& dest_begin, char* dest_end, bool flush );
+    void close();
+};
+
+//
+// Template name: zlib_compressor
+// Description: Model of C-Style Filte implementing decompression by
+//      delegating to the zlib function inflate.
+//
+template<typename Alloc = std::allocator<char> >
+class zlib_decompressor_impl : public zlib_base, public zlib_allocator<Alloc> {
+public:
+    zlib_decompressor_impl(const zlib_params&);
+    zlib_decompressor_impl(int window_bits = zlib::default_window_bits);
+    ~zlib_decompressor_impl();
+    bool filter( const char*& begin_in, const char* end_in,
+                 char*& begin_out, char* end_out, bool flush );
+    void close();
+    bool eof() const { return eof_; }
+private:
+    bool eof_;
+};
+
+} // End namespace detail.
+
+//
+// Template name: zlib_compressor
+// Description: Model of InputFilter and OutputFilter implementing
+//      compression using zlib.
+//
+template<typename Alloc = std::allocator<char> >
+struct basic_zlib_compressor 
+    : symmetric_filter<detail::zlib_compressor_impl<Alloc>, Alloc> 
+{
+private:
+    typedef detail::zlib_compressor_impl<Alloc>         impl_type;
+    typedef symmetric_filter<impl_type, Alloc>  base_type;
+public:
+    typedef typename base_type::char_type               char_type;
+    typedef typename base_type::category                category;
+    basic_zlib_compressor( const zlib_params& = zlib::default_compression, 
+                           std::streamsize buffer_size = default_device_buffer_size );
+    zlib::ulong crc() { return this->filter().crc(); }
+    int total_in() {  return this->filter().total_in(); }
+};
+BOOST_IOSTREAMS_PIPABLE(basic_zlib_compressor, 1)
+
+typedef basic_zlib_compressor<> zlib_compressor;
+
+//
+// Template name: zlib_decompressor
+// Description: Model of InputFilter and OutputFilter implementing
+//      decompression using zlib.
+//
+template<typename Alloc = std::allocator<char> >
+struct basic_zlib_decompressor 
+    : symmetric_filter<detail::zlib_decompressor_impl<Alloc>, Alloc> 
+{
+private:
+    typedef detail::zlib_decompressor_impl<Alloc>       impl_type;
+    typedef symmetric_filter<impl_type, Alloc>  base_type;
+public:
+    typedef typename base_type::char_type               char_type;
+    typedef typename base_type::category                category;
+    basic_zlib_decompressor( int window_bits = zlib::default_window_bits,
+                             std::streamsize buffer_size = default_device_buffer_size );
+    basic_zlib_decompressor( const zlib_params& p,
+                             std::streamsize buffer_size = default_device_buffer_size );
+    zlib::ulong crc() { return this->filter().crc(); }
+    int total_out() {  return this->filter().total_out(); }
+    bool eof() { return this->filter().eof(); }
+};
+BOOST_IOSTREAMS_PIPABLE(basic_zlib_decompressor, 1)
+
+typedef basic_zlib_decompressor<> zlib_decompressor;
+
+//----------------------------------------------------------------------------//
+
+//------------------Implementation of zlib_allocator--------------------------//
+
+namespace detail {
+
+template<typename Alloc, typename Base>
+void* zlib_allocator<Alloc, Base>::allocate
+    (void* self, zlib::uint items, zlib::uint size)
+{ 
+    size_type len = items * size;
+    char* ptr = 
+        static_cast<allocator_type*>(self)->allocate
+            (len + sizeof(size_type)
+            #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+                , (char*)0
+            #endif
+            );
+    *reinterpret_cast<size_type*>(ptr) = len;
+    return ptr + sizeof(size_type);
+}
+
+template<typename Alloc, typename Base>
+void zlib_allocator<Alloc, Base>::deallocate(void* self, void* address)
+{ 
+    char* ptr = reinterpret_cast<char*>(address) - sizeof(size_type);
+    size_type len = *reinterpret_cast<size_type*>(ptr) + sizeof(size_type);
+    static_cast<allocator_type*>(self)->deallocate(ptr, len); 
+}
+
+//------------------Implementation of zlib_compressor_impl--------------------//
+
+template<typename Alloc>
+zlib_compressor_impl<Alloc>::zlib_compressor_impl(const zlib_params& p)
+{ init(p, true, static_cast<zlib_allocator<Alloc>&>(*this)); }
+
+template<typename Alloc>
+zlib_compressor_impl<Alloc>::~zlib_compressor_impl()
+{ reset(true, false); }
+
+template<typename Alloc>
+bool zlib_compressor_impl<Alloc>::filter
+    ( const char*& src_begin, const char* src_end,
+      char*& dest_begin, char* dest_end, bool flush )
+{
+    before(src_begin, src_end, dest_begin, dest_end);
+    int result = xdeflate(flush ? zlib::finish : zlib::no_flush);
+    after(src_begin, dest_begin, true);
+    zlib_error::check BOOST_PREVENT_MACRO_SUBSTITUTION(result);
+    return result != zlib::stream_end;
+}
+
+template<typename Alloc>
+void zlib_compressor_impl<Alloc>::close() { reset(true, true); }
+
+//------------------Implementation of zlib_decompressor_impl------------------//
+
+template<typename Alloc>
+zlib_decompressor_impl<Alloc>::zlib_decompressor_impl(const zlib_params& p)
+  : eof_(false)
+{ init(p, false, static_cast<zlib_allocator<Alloc>&>(*this)); }
+
+template<typename Alloc>
+zlib_decompressor_impl<Alloc>::~zlib_decompressor_impl()
+{ reset(false, false); }
+
+template<typename Alloc>
+zlib_decompressor_impl<Alloc>::zlib_decompressor_impl(int window_bits)
+{ 
+    zlib_params p;
+    p.window_bits = window_bits;
+    init(p, false, static_cast<zlib_allocator<Alloc>&>(*this)); 
+}
+
+template<typename Alloc>
+bool zlib_decompressor_impl<Alloc>::filter
+    ( const char*& src_begin, const char* src_end,
+      char*& dest_begin, char* dest_end, bool /* flush */ )
+{
+    before(src_begin, src_end, dest_begin, dest_end);
+    int result = xinflate(zlib::sync_flush);
+    after(src_begin, dest_begin, false);
+    zlib_error::check BOOST_PREVENT_MACRO_SUBSTITUTION(result);
+    return !(eof_ = result == zlib::stream_end);
+}
+
+template<typename Alloc>
+void zlib_decompressor_impl<Alloc>::close() {
+    eof_ = false;
+    reset(false, true);
+}
+
+} // End namespace detail.
+
+//------------------Implementation of zlib_decompressor-----------------------//
+
+template<typename Alloc>
+basic_zlib_compressor<Alloc>::basic_zlib_compressor
+    (const zlib_params& p, std::streamsize buffer_size) 
+    : base_type(buffer_size, p) { }
+
+//------------------Implementation of zlib_decompressor-----------------------//
+
+template<typename Alloc>
+basic_zlib_decompressor<Alloc>::basic_zlib_decompressor
+    (int window_bits, std::streamsize buffer_size) 
+    : base_type(buffer_size, window_bits) { }
+
+template<typename Alloc>
+basic_zlib_decompressor<Alloc>::basic_zlib_decompressor
+    (const zlib_params& p, std::streamsize buffer_size) 
+    : base_type(buffer_size, p) { }
+
+//----------------------------------------------------------------------------//
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/config/abi_suffix.hpp> // Pops abi_suffix.hpp pragmas.
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
+#endif // #ifndef BOOST_IOSTREAMS_ZLIB_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/filtering_stream.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/filtering_stream.hpp
new file mode 100644
index 0000000000..8621ef96b2
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/filtering_stream.hpp
@@ -0,0 +1,187 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2004-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_FILTER_STREAM_HPP_INCLUDED
+#define BOOST_IOSTREAMS_FILTER_STREAM_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <memory>                                     // allocator.
+#include <boost/iostreams/detail/access_control.hpp>
+#include <boost/iostreams/detail/char_traits.hpp>
+#include <boost/iostreams/detail/iostream.hpp>        // standard streams.
+#include <boost/iostreams/detail/push.hpp>
+#include <boost/iostreams/detail/select.hpp>
+#include <boost/iostreams/detail/streambuf.hpp>       // pubsync.
+#include <boost/iostreams/filtering_streambuf.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>  // MSVC.
+
+namespace boost { namespace iostreams {
+
+//--------------Definition of filtered_istream--------------------------------//
+
+namespace detail {
+
+template<typename Mode, typename Ch, typename Tr>
+struct filtering_stream_traits {
+    typedef typename 
+            iostreams::select<  // Disambiguation for Tru64  
+                mpl::and_< 
+                    is_convertible<Mode, input>, 
+                    is_convertible<Mode, output> 
+                >,          
+                BOOST_IOSTREAMS_BASIC_IOSTREAM(Ch, Tr),
+                is_convertible<Mode, input>, 
+                BOOST_IOSTREAMS_BASIC_ISTREAM(Ch, Tr),
+                else_,        
+                BOOST_IOSTREAMS_BASIC_OSTREAM(Ch, Tr)
+            >::type stream_type;
+    typedef typename
+            iostreams::select< // Dismbiguation required for Tru64.
+                mpl::and_<
+                    is_convertible<Mode, input>,
+                    is_convertible<Mode, output>
+                >,
+                iostream_tag,
+                is_convertible<Mode, input>,
+                istream_tag,
+                else_,
+                ostream_tag
+            >::type stream_tag;
+};
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC == 1700)
+# pragma warning(push)
+// https://connect.microsoft.com/VisualStudio/feedback/details/733720/
+# pragma warning(disable: 4250)
+#endif
+
+template<typename Chain, typename Access>
+class filtering_stream_base 
+    : public access_control<
+                 boost::iostreams::detail::chain_client<Chain>,
+                 Access
+             >,
+      public filtering_stream_traits<
+                 typename Chain::mode, 
+                 typename Chain::char_type, 
+                 typename Chain::traits_type
+             >::stream_type
+{
+public:
+    typedef Chain                                         chain_type;
+    typedef access_control<
+                 boost::iostreams::detail::chain_client<Chain>,
+                 Access
+             >                                            client_type;
+protected:
+    typedef typename 
+            filtering_stream_traits<
+                 typename Chain::mode, 
+                 typename Chain::char_type, 
+                 typename Chain::traits_type
+            >::stream_type                                stream_type;
+    filtering_stream_base() : stream_type(0) { this->set_chain(&chain_); }
+private:
+    void notify() { this->rdbuf(chain_.empty() ? 0 : &chain_.front()); }
+    Chain chain_;
+};
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC == 1700)
+# pragma warning(pop)
+#endif
+
+} // End namespace detail.
+
+//
+// Macro: BOOST_IOSTREAMS_DEFINE_FILTER_STREAM(name_, chain_type_, default_char_)
+// Description: Defines a template derived from std::basic_streambuf which uses
+//      a chain to perform i/o. The template has the following parameters:
+//      Mode - the i/o mode.
+//      Ch - The character type.
+//      Tr - The character traits type.
+//      Alloc - The allocator type.
+//      Access - Indicates accessibility of the chain interface; must be either
+//          public_ or protected_; defaults to public_.
+// Macro parameters:
+//      name_ - The name of the template to be defined.
+//      chain_type_ - The name of the chain template.
+//      default_char_ - The default value for the char template parameter.
+//
+#define BOOST_IOSTREAMS_DEFINE_FILTER_STREAM(name_, chain_type_, default_char_) \
+    template< typename Mode, \
+              typename Ch = default_char_, \
+              typename Tr = BOOST_IOSTREAMS_CHAR_TRAITS(Ch), \
+              typename Alloc = std::allocator<Ch>, \
+              typename Access = public_ > \
+    class name_ \
+        : public boost::iostreams::detail::filtering_stream_base< \
+                     chain_type_<Mode, Ch, Tr, Alloc>, Access \
+                 > \
+    { \
+    public: \
+        typedef Ch                                char_type; \
+        struct category \
+            : Mode, \
+              closable_tag, \
+              detail::filtering_stream_traits<Mode, Ch, Tr>::stream_tag \
+            { }; \
+        BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr) \
+        typedef Mode                              mode; \
+        typedef chain_type_<Mode, Ch, Tr, Alloc>  chain_type; \
+        name_() { } \
+        BOOST_IOSTREAMS_DEFINE_PUSH_CONSTRUCTOR(name_, mode, Ch, push_impl) \
+        ~name_() { \
+            if (this->is_complete()) \
+                 this->rdbuf()->BOOST_IOSTREAMS_PUBSYNC(); \
+        } \
+    private: \
+        typedef access_control< \
+                    boost::iostreams::detail::chain_client< \
+                        chain_type_<Mode, Ch, Tr, Alloc> \
+                    >, \
+                    Access \
+                > client_type; \
+        template<typename T> \
+        void push_impl(const T& t BOOST_IOSTREAMS_PUSH_PARAMS()) \
+        { client_type::push(t BOOST_IOSTREAMS_PUSH_ARGS()); } \
+    }; \
+    /**/    
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC == 1700)
+# pragma warning(push)
+// https://connect.microsoft.com/VisualStudio/feedback/details/733720/
+# pragma warning(disable: 4250)
+#endif
+
+BOOST_IOSTREAMS_DEFINE_FILTER_STREAM(filtering_stream, boost::iostreams::chain, char)
+BOOST_IOSTREAMS_DEFINE_FILTER_STREAM(wfiltering_stream, boost::iostreams::chain, wchar_t)
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC == 1700)
+# pragma warning(pop)
+#endif
+
+typedef filtering_stream<input>    filtering_istream;
+typedef filtering_stream<output>   filtering_ostream;
+typedef wfiltering_stream<input>   filtering_wistream;
+typedef wfiltering_stream<output>  filtering_wostream;
+
+//----------------------------------------------------------------------------//
+
+} } // End namespace iostreams, boost
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC
+
+#endif // #ifndef BOOST_IOSTREAMS_FILTER_STREAM_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/filtering_streambuf.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/filtering_streambuf.hpp
new file mode 100644
index 0000000000..affe4a71c4
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/filtering_streambuf.hpp
@@ -0,0 +1,70 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_FILTERING_STREAMBUF_HPP_INCLUDED
+#define BOOST_IOSTREAMS_FILTERING_STREAMBUF_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <exception>
+#include <memory>                               // allocator.
+#include <boost/iostreams/chain.hpp>
+#include <boost/iostreams/detail/access_control.hpp>
+#include <boost/iostreams/detail/char_traits.hpp>
+#include <boost/iostreams/detail/push.hpp>
+#include <boost/iostreams/detail/streambuf.hpp> // pubsync.
+#include <boost/iostreams/detail/streambuf/chainbuf.hpp>
+#include <boost/mpl/if.hpp>                    
+
+namespace boost { namespace iostreams {
+
+//
+// Macro: BOOST_IOSTREAMS_DEFINE_FILTERBUF(name_, chain_type_, default_char_)
+// Description: Defines a template derived from std::basic_streambuf which uses
+//      a chain to perform i/o. The template has the following parameters:
+//      Ch - The character type.
+//      Tr - The character traits type.
+//      Alloc - The allocator type.
+//      Access - Indicates accessibility of the chain interface; must be either
+//          public_ or protected_; defaults to public_.
+//
+#define BOOST_IOSTREAMS_DEFINE_FILTER_STREAMBUF(name_, chain_type_, default_char_) \
+    template< typename Mode, \
+              typename Ch = default_char_, \
+              typename Tr = BOOST_IOSTREAMS_CHAR_TRAITS(Ch), \
+              typename Alloc = std::allocator<Ch>, \
+              typename Access = public_ > \
+    class name_ : public boost::iostreams::detail::chainbuf< \
+                             chain_type_<Mode, Ch, Tr, Alloc>, Mode, Access \
+                         > \
+    { \
+    public: \
+        typedef Ch                                             char_type; \
+        struct category \
+            : Mode, closable_tag, streambuf_tag \
+            { }; \
+        BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr) \
+        typedef Mode                                           mode; \
+        typedef chain_type_<Mode, Ch, Tr, Alloc>               chain_type; \
+        name_() { } \
+        BOOST_IOSTREAMS_DEFINE_PUSH_CONSTRUCTOR(name_, mode, Ch, push_impl) \
+        ~name_() { if (this->is_complete()) this->BOOST_IOSTREAMS_PUBSYNC(); } \
+    }; \
+    /**/ 
+BOOST_IOSTREAMS_DEFINE_FILTER_STREAMBUF(filtering_streambuf, boost::iostreams::chain, char)
+BOOST_IOSTREAMS_DEFINE_FILTER_STREAMBUF(filtering_wstreambuf, boost::iostreams::chain, wchar_t)
+
+typedef filtering_streambuf<input>    filtering_istreambuf;
+typedef filtering_streambuf<output>   filtering_ostreambuf;
+typedef filtering_wstreambuf<input>   filtering_wistreambuf;
+typedef filtering_wstreambuf<output>  filtering_wostreambuf;
+
+} } // End namespaces iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_FILTERING_STREAMBUF_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/flush.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/flush.hpp
new file mode 100644
index 0000000000..5212a448f1
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/flush.hpp
@@ -0,0 +1,125 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_FLUSH_HPP_INCLUDED
+#define BOOST_IOSTREAMS_FLUSH_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp>  // DEDUCED_TYPENAME, MSVC.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/detail/dispatch.hpp>
+#include <boost/iostreams/detail/streambuf.hpp>
+#include <boost/iostreams/detail/wrap_unwrap.hpp>
+#include <boost/iostreams/operations_fwd.hpp>
+#include <boost/iostreams/traits.hpp>
+#include <boost/mpl/if.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>
+
+namespace boost { namespace iostreams {
+
+namespace detail {
+
+template<typename T>
+struct flush_device_impl;
+
+template<typename T>
+struct flush_filter_impl;
+
+} // End namespace detail.
+
+template<typename T>
+bool flush(T& t)
+{ return detail::flush_device_impl<T>::flush(detail::unwrap(t)); }
+
+template<typename T, typename Sink>
+bool flush(T& t, Sink& snk)
+{ return detail::flush_filter_impl<T>::flush(detail::unwrap(t), snk); }
+
+namespace detail {
+
+//------------------Definition of flush_device_impl---------------------------//
+
+template<typename T>
+struct flush_device_impl
+    : mpl::if_<
+          is_custom<T>,
+          operations<T>,
+          flush_device_impl<
+              BOOST_DEDUCED_TYPENAME
+              dispatch<
+                  T, ostream_tag, streambuf_tag, flushable_tag, any_tag
+              >::type
+          >
+      >::type
+    { };
+
+template<>
+struct flush_device_impl<ostream_tag> {
+    template<typename T>
+    static bool flush(T& t)
+    { return t.rdbuf()->BOOST_IOSTREAMS_PUBSYNC() == 0; }
+};
+
+template<>
+struct flush_device_impl<streambuf_tag> {
+    template<typename T>
+    static bool flush(T& t)
+    { return t.BOOST_IOSTREAMS_PUBSYNC() == 0; }
+};
+
+template<>
+struct flush_device_impl<flushable_tag> {
+    template<typename T>
+    static bool flush(T& t) { return t.flush(); }
+};
+
+template<>
+struct flush_device_impl<any_tag> {
+    template<typename T>
+    static bool flush(T&) { return true; }
+};
+
+//------------------Definition of flush_filter_impl---------------------------//
+
+template<typename T>
+struct flush_filter_impl
+    : mpl::if_<
+          is_custom<T>,
+          operations<T>,
+          flush_filter_impl<
+              BOOST_DEDUCED_TYPENAME
+              dispatch<
+                  T, flushable_tag, any_tag
+              >::type
+          >
+      >::type
+    { };
+
+template<>
+struct flush_filter_impl<flushable_tag> {
+    template<typename T, typename Sink>
+    static bool flush(T& t, Sink& snk) { return t.flush(snk); }
+};
+
+template<>
+struct flush_filter_impl<any_tag> {
+    template<typename T, typename Sink>
+    static bool flush(T&, Sink&) { return false; }
+};
+
+} // End namespace detail.
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp>
+
+#endif // #ifndef BOOST_IOSTREAMS_FLUSH_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/get.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/get.hpp
new file mode 100644
index 0000000000..12d530fd81
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/get.hpp
@@ -0,0 +1,17 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2005-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_GET_HPP_INCLUDED
+#define BOOST_IOSTREAMS_GET_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/iostreams/read.hpp>
+
+#endif // #ifndef BOOST_IOSTREAMS_GET_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/imbue.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/imbue.hpp
new file mode 100644
index 0000000000..48d2e1845a
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/imbue.hpp
@@ -0,0 +1,82 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_IMBUE_HPP_INCLUDED
+#define BOOST_IOSTREAMS_IMBUE_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp>  // DEDUCED_TYPENAME, MSVC.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/detail/dispatch.hpp>
+#include <boost/iostreams/detail/streambuf.hpp>
+#include <boost/iostreams/detail/wrap_unwrap.hpp>
+#include <boost/iostreams/operations_fwd.hpp>
+#include <boost/mpl/if.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>
+
+namespace boost { namespace iostreams { 
+
+namespace detail {
+
+// Implementation templates for simulated tag dispatch.
+template<typename T> 
+struct imbue_impl;
+
+} // End namespace detail.
+
+template<typename T, typename Locale>
+void imbue(T& t, const Locale& loc)
+{ detail::imbue_impl<T>::imbue(detail::unwrap(t), loc); }
+
+namespace detail {
+
+//------------------Definition of imbue_impl----------------------------------//
+
+template<typename T>
+struct imbue_impl
+    : mpl::if_<
+          is_custom<T>,
+          operations<T>,
+          imbue_impl<
+              BOOST_DEDUCED_TYPENAME
+              dispatch<
+                  T, streambuf_tag, localizable_tag, any_tag
+              >::type
+          >
+      >::type
+    { };
+
+template<>
+struct imbue_impl<any_tag> {
+    template<typename T, typename Locale>
+    static void imbue(T&, const Locale&) { }
+};
+
+template<>
+struct imbue_impl<streambuf_tag> {
+    template<typename T, typename Locale>
+    static void imbue(T& t, const Locale& loc) { t.pubimbue(loc); }
+};
+
+template<>
+struct imbue_impl<localizable_tag> {
+    template<typename T, typename Locale>
+    static void imbue(T& t, const Locale& loc) { t.imbue(loc); }
+};
+
+} // End namespace detail.
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp>
+
+#endif // #ifndef BOOST_IOSTREAMS_IMBUE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/input_sequence.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/input_sequence.hpp
new file mode 100644
index 0000000000..e504c8e8ff
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/input_sequence.hpp
@@ -0,0 +1,72 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_INPUT_SEQUENCE_HPP_INCLUDED
+#define BOOST_IOSTREAMS_INPUT_SEQUENCE_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <utility>           // pair.
+#include <boost/config.hpp>  // DEDUCED_TYPENAME, MSVC.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/detail/wrap_unwrap.hpp>
+#include <boost/iostreams/operations_fwd.hpp>  // is_custom 
+#include <boost/iostreams/traits.hpp>
+#include <boost/mpl/if.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>
+
+namespace boost { namespace iostreams {
+
+namespace detail {
+
+template<typename T>
+struct input_sequence_impl;
+
+} // End namespace detail.
+
+template<typename T>
+inline std::pair<
+    BOOST_DEDUCED_TYPENAME char_type_of<T>::type*,
+    BOOST_DEDUCED_TYPENAME char_type_of<T>::type*
+>
+input_sequence(T& t)
+{ return detail::input_sequence_impl<T>::input_sequence(t); }
+
+namespace detail {
+
+//------------------Definition of direct_impl-------------------------------//
+
+template<typename T>
+struct input_sequence_impl
+    : mpl::if_<
+          detail::is_custom<T>,
+          operations<T>,
+          input_sequence_impl<direct_tag>
+      >::type
+    { };
+
+template<>
+struct input_sequence_impl<direct_tag> {
+    template<typename U>
+    static std::pair<
+        BOOST_DEDUCED_TYPENAME char_type_of<U>::type*,
+        BOOST_DEDUCED_TYPENAME char_type_of<U>::type*
+    >
+    input_sequence(U& u) { return u.input_sequence(); }
+};
+
+} // End namespace detail.
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp>
+
+#endif // #ifndef BOOST_IOSTREAMS_INPUT_SEQUENCE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/operations.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/operations.hpp
new file mode 100644
index 0000000000..28bd773172
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/operations.hpp
@@ -0,0 +1,26 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2005-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_OPERATIONS_HPP_INCLUDED
+#define BOOST_IOSTREAMS_OPERATIONS_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/iostreams/operations_fwd.hpp>
+#include <boost/iostreams/close.hpp>
+#include <boost/iostreams/flush.hpp>
+#include <boost/iostreams/imbue.hpp>
+#include <boost/iostreams/input_sequence.hpp>
+#include <boost/iostreams/optimal_buffer_size.hpp>
+#include <boost/iostreams/output_sequence.hpp>
+#include <boost/iostreams/read.hpp>
+#include <boost/iostreams/seek.hpp>
+#include <boost/iostreams/write.hpp>
+
+#endif // #ifndef BOOST_IOSTREAMS_OPERATIONS_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/operations_fwd.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/operations_fwd.hpp
new file mode 100644
index 0000000000..ae68d70467
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/operations_fwd.hpp
@@ -0,0 +1,41 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_OPERATIONS_FWD_HPP_INCLUDED
+#define BOOST_IOSTREAMS_OPERATIONS_FWD_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+namespace boost { namespace iostreams {
+
+template<typename T>
+struct operations;
+
+namespace detail {
+
+struct custom_tag { };
+
+template<typename T>
+struct is_custom
+    : mpl::not_<
+          is_base_and_derived< custom_tag, operations<T> >
+      >
+    { };
+
+} // End namespace detail.
+
+template<typename T>
+struct operations : detail::custom_tag { };
+
+} } // End namespaces iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_OPERATIONS_FWD_HPP_INCLUDED //--------------//
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/optimal_buffer_size.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/optimal_buffer_size.hpp
new file mode 100644
index 0000000000..13894faab8
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/optimal_buffer_size.hpp
@@ -0,0 +1,87 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_OPTIMAL_BUFFER_SIZE_HPP_INCLUDED
+#define BOOST_IOSTREAMS_OPTIMAL_BUFFER_SIZE_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp>  // DEDUCED_TYPENAME, MSVC.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/constants.hpp>  // constants.
+#include <boost/iostreams/detail/dispatch.hpp>
+#include <boost/iostreams/detail/wrap_unwrap.hpp>
+#include <boost/iostreams/operations_fwd.hpp>
+#include <boost/mpl/if.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>
+
+namespace boost { namespace iostreams {
+
+namespace detail {
+
+template<typename T>
+struct optimal_buffer_size_impl;
+
+} // End namespace detail.
+
+template<typename T>
+std::streamsize optimal_buffer_size(const T& t)
+{
+    typedef detail::optimal_buffer_size_impl<T> impl;
+    return impl::optimal_buffer_size(detail::unwrap(t));
+}
+
+namespace detail {
+
+//------------------Definition of optimal_buffer_size_impl--------------------//
+
+template<typename T>
+struct optimal_buffer_size_impl
+    : mpl::if_<
+          is_custom<T>,
+          operations<T>,
+          optimal_buffer_size_impl<
+              BOOST_DEDUCED_TYPENAME
+              dispatch<
+                  T, optimally_buffered_tag, device_tag, filter_tag
+              >::type
+          >
+      >::type
+    { };
+
+template<>
+struct optimal_buffer_size_impl<optimally_buffered_tag> {
+    template<typename T>
+    static std::streamsize optimal_buffer_size(const T& t)
+    { return t.optimal_buffer_size(); }
+};
+
+template<>
+struct optimal_buffer_size_impl<device_tag> {
+    template<typename T>
+    static std::streamsize optimal_buffer_size(const T&)
+    { return default_device_buffer_size; }
+};
+
+template<>
+struct optimal_buffer_size_impl<filter_tag> {
+    template<typename T>
+    static std::streamsize optimal_buffer_size(const T&)
+    { return default_filter_buffer_size; }
+};
+
+} // End namespace detail.
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp>
+
+#endif // #ifndef BOOST_IOSTREAMS_OPTIMAL_BUFFER_SIZE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/output_sequence.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/output_sequence.hpp
new file mode 100644
index 0000000000..5b42bf457d
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/output_sequence.hpp
@@ -0,0 +1,72 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_OUTPUT_SEQUENCE_HPP_INCLUDED
+#define BOOST_IOSTREAMS_OUTPUT_SEQUENCE_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <utility>           // pair.
+#include <boost/config.hpp>  // DEDUCED_TYPENAME, MSVC.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/detail/wrap_unwrap.hpp>
+#include <boost/iostreams/operations_fwd.hpp>  // is_custom 
+#include <boost/iostreams/traits.hpp>
+#include <boost/mpl/if.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>
+
+namespace boost { namespace iostreams {
+
+namespace detail {
+
+template<typename T>
+struct output_sequence_impl;
+
+} // End namespace detail.
+
+template<typename T>
+inline std::pair<
+    BOOST_DEDUCED_TYPENAME char_type_of<T>::type*,
+    BOOST_DEDUCED_TYPENAME char_type_of<T>::type*
+>
+output_sequence(T& t)
+{ return detail::output_sequence_impl<T>::output_sequence(t); }
+
+namespace detail {
+
+//------------------Definition of output_sequence_impl------------------------//
+
+template<typename T>
+struct output_sequence_impl
+    : mpl::if_<
+          detail::is_custom<T>,
+          operations<T>,
+          output_sequence_impl<direct_tag>
+      >::type
+    { };
+
+template<>
+struct output_sequence_impl<direct_tag> {
+    template<typename U>
+    static std::pair<
+        BOOST_DEDUCED_TYPENAME char_type_of<U>::type*,
+        BOOST_DEDUCED_TYPENAME char_type_of<U>::type*
+    >
+    output_sequence(U& u) { return u.output_sequence(); }
+};
+
+} // End namespace detail.
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp>
+
+#endif // #ifndef BOOST_IOSTREAMS_OUTPUT_SEQUENCE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/pipeline.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/pipeline.hpp
new file mode 100644
index 0000000000..d29c2da3f7
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/pipeline.hpp
@@ -0,0 +1,114 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_PIPABLE_HPP_INCLUDED
+#define BOOST_IOSTREAMS_PIPABLE_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp> // BOOST_MSVC.
+#include <boost/detail/workaround.hpp>           
+#include <boost/iostreams/detail/template_params.hpp>
+#include <boost/iostreams/traits.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/static_assert.hpp>
+
+#define BOOST_IOSTREAMS_PIPABLE(filter, arity) \
+    template< BOOST_PP_ENUM_PARAMS(arity, typename T) \
+              BOOST_PP_COMMA_IF(arity) typename Component> \
+    ::boost::iostreams::pipeline< \
+        ::boost::iostreams::detail::pipeline_segment< \
+            filter BOOST_IOSTREAMS_TEMPLATE_ARGS(arity, T) \
+        >, \
+        Component \
+    > operator|( const filter BOOST_IOSTREAMS_TEMPLATE_ARGS(arity, T)& f, \
+                 const Component& c ) \
+    { \
+        typedef ::boost::iostreams::detail::pipeline_segment< \
+                    filter BOOST_IOSTREAMS_TEMPLATE_ARGS(arity, T) \
+                > segment; \
+        return ::boost::iostreams::pipeline<segment, Component> \
+                   (segment(f), c); \
+    } \
+    /**/
+
+namespace boost { namespace iostreams {
+
+template<typename Pipeline, typename Component>
+struct pipeline;
+    
+namespace detail {
+
+#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+    template<typename T>
+    struct is_pipeline : mpl::false_ { };
+
+    template<typename Pipeline, typename Component>
+    struct is_pipeline< pipeline<Pipeline, Component> > : mpl::true_ { };
+#endif
+
+template<typename Component>
+class pipeline_segment 
+{
+public:
+    pipeline_segment(const Component& component) 
+        : component_(component) 
+        { }
+    template<typename Fn>
+    void for_each(Fn fn) const { fn(component_); }
+    template<typename Chain>
+    void push(Chain& chn) const { chn.push(component_); }
+private:
+    pipeline_segment operator=(const pipeline_segment&);
+    const Component& component_;
+};
+
+} // End namespace detail.
+                    
+//------------------Definition of Pipeline------------------------------------//
+
+template<typename Pipeline, typename Component>
+struct pipeline : Pipeline {
+    typedef Pipeline   pipeline_type;
+    typedef Component  component_type;
+    pipeline(const Pipeline& p, const Component& component)
+        : Pipeline(p), component_(component)
+        { }
+    template<typename Fn>
+    void for_each(Fn fn) const
+    {
+        Pipeline::for_each(fn);
+        fn(component_);
+    }
+    template<typename Chain>
+    void push(Chain& chn) const
+    { 
+        Pipeline::push(chn);
+        chn.push(component_);
+    }
+    const Pipeline& tail() const { return *this; }
+    const Component& head() const { return component_; }
+private:
+    pipeline operator=(const pipeline&);
+    const Component& component_;
+};
+
+template<typename Pipeline, typename Filter, typename Component>
+pipeline<pipeline<Pipeline, Filter>, Component>
+operator|(const pipeline<Pipeline, Filter>& p, const Component& cmp)
+{
+    BOOST_STATIC_ASSERT(is_filter<Filter>::value);
+    return pipeline<pipeline<Pipeline, Filter>, Component>(p, cmp);
+}
+
+} } // End namespaces iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_PIPABLE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/positioning.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/positioning.hpp
new file mode 100644
index 0000000000..12f2afc84b
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/positioning.hpp
@@ -0,0 +1,117 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Thanks to Gareth Sylvester-Bradley for the Dinkumware versions of the
+// positioning functions.
+
+#ifndef BOOST_IOSTREAMS_POSITIONING_HPP_INCLUDED
+#define BOOST_IOSTREAMS_POSITIONING_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/integer_traits.hpp>
+#include <boost/iostreams/detail/config/codecvt.hpp> // mbstate_t.
+#include <boost/iostreams/detail/config/fpos.hpp>
+#include <boost/iostreams/detail/ios.hpp> // streamoff, streampos.
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp> 
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std { using ::fpos_t; }
+#endif
+
+namespace boost { namespace iostreams {
+                    
+//------------------Definition of stream_offset-------------------------------//
+
+typedef boost::intmax_t stream_offset;
+
+//------------------Definition of stream_offset_to_streamoff------------------//
+
+inline std::streamoff stream_offset_to_streamoff(stream_offset off)
+{ return static_cast<stream_offset>(off); }
+
+//------------------Definition of offset_to_position--------------------------//
+
+# ifndef BOOST_IOSTREAMS_HAS_DINKUMWARE_FPOS
+
+inline std::streampos offset_to_position(stream_offset off) { return off; }
+
+# else // # ifndef BOOST_IOSTREAMS_HAS_DINKUMWARE_FPOS
+
+inline std::streampos offset_to_position(stream_offset off)
+{ return std::streampos(std::mbstate_t(), off); }
+
+# endif // # ifndef BOOST_IOSTREAMS_HAS_DINKUMWARE_FPOS
+
+//------------------Definition of position_to_offset--------------------------//
+
+// Hande custom pos_type's
+template<typename PosType> 
+inline stream_offset position_to_offset(PosType pos)
+{ return std::streamoff(pos); }
+
+# ifndef BOOST_IOSTREAMS_HAS_DINKUMWARE_FPOS
+
+inline stream_offset position_to_offset(std::streampos pos) { return pos; }
+
+# else // # ifndef BOOST_IOSTREAMS_HAS_DINKUMWARE_FPOS
+
+// In the Dinkumware standard library, a std::streampos consists of two stream
+// offsets -- _Fpos, of type std::fpos_t, and _Myoff, of type std::streamoff --
+// together with a conversion state. A std::streampos is converted to a 
+// boost::iostreams::stream_offset by extracting the two stream offsets and
+// summing them. The value of _Fpos can be extracted using the implementation-
+// defined member functions seekpos() or get_fpos_t(), depending on the 
+// Dinkumware version. The value of _Myoff cannot be extracted directly, but can
+// be calculated as the difference between the result of converting the 
+// std::fpos to a std::streamoff and the result of converting the member _Fpos
+// to a long. The latter operation is accomplished with the macro BOOST_IOSTREAMS_FPOSOFF,
+// which works correctly on platforms where std::fpos_t is an integral type and 
+// platforms where it is a struct
+
+// Converts a std::fpos_t to a stream_offset
+inline stream_offset fpos_t_to_offset(std::fpos_t pos)
+{
+#  if defined(_POSIX_) || (_INTEGRAL_MAX_BITS >= 64) || defined(__IBMCPP__)
+    return pos;
+#  else
+    return BOOST_IOSTREAMS_FPOSOFF(pos);
+#  endif
+}
+
+// Extracts the member _Fpos from a std::fpos
+inline std::fpos_t streampos_to_fpos_t(std::streampos pos)
+{
+#  if defined (_CPPLIB_VER) || defined(__IBMCPP__)
+    return pos.seekpos();
+#  else
+    return pos.get_fpos_t();
+#  endif
+}
+
+inline stream_offset position_to_offset(std::streampos pos)
+{
+    return fpos_t_to_offset(streampos_to_fpos_t(pos)) +
+        static_cast<stream_offset>(
+            static_cast<std::streamoff>(pos) -
+            BOOST_IOSTREAMS_FPOSOFF(streampos_to_fpos_t(pos))
+        );
+}
+
+# endif // # ifndef BOOST_IOSTREAMS_HAS_DINKUMWARE_FPOS 
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp> 
+
+#endif // #ifndef BOOST_IOSTREAMS_POSITIONING_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/put.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/put.hpp
new file mode 100644
index 0000000000..a3fe33f207
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/put.hpp
@@ -0,0 +1,17 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2005-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_PUT_HPP_INCLUDED
+#define BOOST_IOSTREAMS_PUT_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/iostreams/write.hpp>
+
+#endif // #ifndef BOOST_IOSTREAMS_PUT_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/putback.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/putback.hpp
new file mode 100644
index 0000000000..a4969f641a
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/putback.hpp
@@ -0,0 +1,17 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2005-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_PUTBACK_HPP_INCLUDED
+#define BOOST_IOSTREAMS_PUTBACK_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/iostreams/read.hpp>
+
+#endif // #ifndef BOOST_IOSTREAMS_PUTBACK_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/read.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/read.hpp
new file mode 100644
index 0000000000..a8652c5644
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/read.hpp
@@ -0,0 +1,241 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2005-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_READ_HPP_INCLUDED
+#define BOOST_IOSTREAMS_READ_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp>  // DEDUCED_TYPENAME, MSVC.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/char_traits.hpp>
+#include <boost/iostreams/detail/char_traits.hpp>
+#include <boost/iostreams/detail/dispatch.hpp>
+#include <boost/iostreams/detail/ios.hpp>  // streamsize.
+#include <boost/iostreams/detail/streambuf.hpp>
+#include <boost/iostreams/detail/wrap_unwrap.hpp>
+#include <boost/iostreams/operations_fwd.hpp>
+#include <boost/mpl/if.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>
+
+namespace boost { namespace iostreams {
+
+namespace detail {
+
+template<typename T>
+struct read_device_impl;
+
+template<typename T>
+struct read_filter_impl;
+
+} // End namespace detail.
+
+template<typename T>
+typename int_type_of<T>::type get(T& t)
+{ return detail::read_device_impl<T>::get(detail::unwrap(t)); }
+
+template<typename T>
+inline std::streamsize
+read(T& t, typename char_type_of<T>::type* s, std::streamsize n)
+{ return detail::read_device_impl<T>::read(detail::unwrap(t), s, n); }
+
+template<typename T, typename Source>
+std::streamsize
+read(T& t, Source& src, typename char_type_of<T>::type* s, std::streamsize n)
+{ return detail::read_filter_impl<T>::read(detail::unwrap(t), src, s, n); }
+
+template<typename T>
+bool putback(T& t, typename char_type_of<T>::type c)
+{ return detail::read_device_impl<T>::putback(detail::unwrap(t), c); }
+
+//----------------------------------------------------------------------------//
+
+namespace detail {
+
+// Helper function for adding -1 as EOF indicator.
+inline std::streamsize check_eof(std::streamsize n) { return n != 0 ? n : -1; }
+
+// Helper templates for reading from streambufs.
+template<bool IsLinked>
+struct true_eof_impl;
+
+template<>
+struct true_eof_impl<true> {
+    template<typename T>
+    static bool true_eof(T& t) { return t.true_eof(); }
+};
+
+template<>
+struct true_eof_impl<false> {
+    template<typename T>
+    static bool true_eof(T&) { return true; }
+};
+
+template<typename T>
+inline bool true_eof(T& t)
+{
+    const bool linked = is_linked<T>::value;
+    return true_eof_impl<linked>::true_eof(t);
+}
+
+//------------------Definition of read_device_impl----------------------------//
+
+template<typename T>
+struct read_device_impl
+    : mpl::if_<
+          detail::is_custom<T>,
+          operations<T>,
+          read_device_impl<
+              BOOST_DEDUCED_TYPENAME
+              detail::dispatch<
+                  T, istream_tag, streambuf_tag, input
+              >::type
+          >
+      >::type
+    { };
+
+template<>
+struct read_device_impl<istream_tag> {
+    template<typename T>
+    static typename int_type_of<T>::type get(T& t)
+    { return t.get(); }
+
+    template<typename T>
+    static std::streamsize
+    read(T& t, typename char_type_of<T>::type* s, std::streamsize n)
+    { return check_eof(t.rdbuf()->sgetn(s, n)); }
+
+    template<typename T>
+    static bool putback(T& t, typename char_type_of<T>::type c)
+    {
+        typedef typename char_type_of<T>::type          char_type;
+        typedef BOOST_IOSTREAMS_CHAR_TRAITS(char_type)  traits_type;
+        return !traits_type::eq_int_type( t.rdbuf()->sputbackc(c),
+                                          traits_type::eof() );
+    }
+};
+
+template<>
+struct read_device_impl<streambuf_tag> {
+    template<typename T>
+    static typename int_type_of<T>::type
+    get(T& t)
+    {   // gcc 2.95 needs namespace qualification for char_traits.
+        typedef typename char_type_of<T>::type     char_type;
+        typedef iostreams::char_traits<char_type>  traits_type;
+        typename int_type_of<T>::type c;
+        return !traits_type::is_eof(c = t.sbumpc()) ||
+                detail::true_eof(t)
+                    ?
+                c : traits_type::would_block();
+    }
+
+    template<typename T>
+    static std::streamsize
+    read(T& t, typename char_type_of<T>::type* s, std::streamsize n)
+    {
+        std::streamsize amt;
+        return (amt = t.sgetn(s, n)) != 0 ?
+            amt :
+            detail::true_eof(t) ?
+                -1 :
+                0;
+    }
+
+    template<typename T>
+    static bool putback(T& t, typename char_type_of<T>::type c)
+    {   // gcc 2.95 needs namespace qualification for char_traits.
+        typedef typename char_type_of<T>::type     char_type;
+        typedef iostreams::char_traits<char_type>  traits_type;
+        return !traits_type::is_eof(t.sputbackc(c));
+    }
+};
+
+template<>
+struct read_device_impl<input> {
+    template<typename T>
+    static typename int_type_of<T>::type
+    get(T& t)
+    {   // gcc 2.95 needs namespace qualification for char_traits.
+        typedef typename char_type_of<T>::type     char_type;
+        typedef iostreams::char_traits<char_type>  traits_type;
+        char_type c;
+        std::streamsize amt;
+        return (amt = t.read(&c, 1)) == 1 ?
+            traits_type::to_int_type(c) :
+            amt == -1 ?
+                traits_type::eof() :
+                traits_type::would_block();
+    }
+
+    template<typename T>
+    static std::streamsize
+    read(T& t, typename char_type_of<T>::type* s, std::streamsize n)
+    { return t.read(s, n); }
+
+    template<typename T>
+    static bool putback(T& t, typename char_type_of<T>::type c)
+    {   // T must be Peekable.
+        return t.putback(c);
+    }
+};
+
+//------------------Definition of read_filter_impl----------------------------//
+
+template<typename T>
+struct read_filter_impl
+    : mpl::if_<
+          detail::is_custom<T>,
+          operations<T>,
+          read_filter_impl<
+              BOOST_DEDUCED_TYPENAME
+              detail::dispatch<
+                  T, multichar_tag, any_tag
+              >::type
+          >
+      >::type
+    { };
+
+template<>
+struct read_filter_impl<multichar_tag> {
+    template<typename T, typename Source>
+    static std::streamsize read
+       (T& t, Source& src, typename char_type_of<T>::type* s, std::streamsize n)
+    { return t.read(src, s, n); }
+};
+
+template<>
+struct read_filter_impl<any_tag> {
+    template<typename T, typename Source>
+    static std::streamsize read
+       (T& t, Source& src, typename char_type_of<T>::type* s, std::streamsize n)
+    {   // gcc 2.95 needs namespace qualification for char_traits.
+        typedef typename char_type_of<T>::type     char_type;
+        typedef iostreams::char_traits<char_type>  traits_type;
+        for (std::streamsize off = 0; off < n; ++off) {
+            typename traits_type::int_type c = t.get(src);
+            if (traits_type::is_eof(c))
+                return check_eof(off);
+            if (traits_type::would_block(c))
+                return off;
+            s[off] = traits_type::to_char_type(c);
+        }
+        return n;
+    }
+};
+
+} // End namespace detail.
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp>
+
+#endif // #ifndef BOOST_IOSTREAMS_READ_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/seek.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/seek.hpp
new file mode 100644
index 0000000000..148c90bfa8
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/seek.hpp
@@ -0,0 +1,180 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_SEEK_HPP_INCLUDED
+#define BOOST_IOSTREAMS_SEEK_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp>  // DEDUCED_TYPENAME, MSVC.
+#include <boost/integer_traits.hpp>
+#include <boost/iostreams/categories.hpp>
+#include <boost/iostreams/detail/dispatch.hpp>
+#include <boost/iostreams/detail/ios.hpp>       // streamsize, seekdir, openmode.
+#include <boost/iostreams/detail/streambuf.hpp>
+#include <boost/iostreams/detail/wrap_unwrap.hpp>
+#include <boost/iostreams/operations_fwd.hpp>
+#include <boost/iostreams/positioning.hpp>
+#include <boost/mpl/if.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>
+
+namespace boost { namespace iostreams {
+
+namespace detail {
+
+template<typename T>
+struct seek_device_impl;
+
+template<typename T>
+struct seek_filter_impl;
+
+} // End namespace detail.
+
+template<typename T>
+inline std::streampos
+seek( T& t, stream_offset off, BOOST_IOS::seekdir way,
+      BOOST_IOS::openmode which = BOOST_IOS::in | BOOST_IOS::out )
+{ 
+    using namespace detail;
+    return seek_device_impl<T>::seek(detail::unwrap(t), off, way, which); 
+}
+
+template<typename T, typename Device>
+inline std::streampos
+seek( T& t, Device& dev, stream_offset off, BOOST_IOS::seekdir way,
+      BOOST_IOS::openmode which = BOOST_IOS::in | BOOST_IOS::out )
+{ 
+    using namespace detail;
+    return seek_filter_impl<T>::seek(detail::unwrap(t), dev, off, way, which);
+}
+
+namespace detail {
+
+//------------------Definition of seek_device_impl----------------------------//
+
+template<typename T>
+struct seek_device_impl
+    : mpl::if_<
+          is_custom<T>,
+          operations<T>,
+          seek_device_impl<
+              BOOST_DEDUCED_TYPENAME
+              dispatch<
+                  T, iostream_tag, istream_tag, ostream_tag,
+                  streambuf_tag, two_head, any_tag
+              >::type
+          >
+      >::type
+    { };
+
+struct seek_impl_basic_ios {
+    template<typename T>
+    static std::streampos seek( T& t, stream_offset off,
+                                BOOST_IOS::seekdir way,
+                                BOOST_IOS::openmode which )
+    {
+        if ( way == BOOST_IOS::beg &&
+             ( off < integer_traits<std::streamoff>::const_min ||
+               off > integer_traits<std::streamoff>::const_max ) )
+        {
+            return t.rdbuf()->pubseekpos(offset_to_position(off));
+        } else {
+            return t.rdbuf()->pubseekoff(off, way, which);
+        }
+    }
+};
+
+template<>
+struct seek_device_impl<iostream_tag> : seek_impl_basic_ios { };
+
+template<>
+struct seek_device_impl<istream_tag> : seek_impl_basic_ios { };
+
+template<>
+struct seek_device_impl<ostream_tag> : seek_impl_basic_ios { };
+
+template<>
+struct seek_device_impl<streambuf_tag> {
+    template<typename T>
+    static std::streampos seek( T& t, stream_offset off,
+                                BOOST_IOS::seekdir way,
+                                BOOST_IOS::openmode which )
+    {
+        if ( way == BOOST_IOS::beg &&
+             ( off < integer_traits<std::streamoff>::const_min ||
+               off > integer_traits<std::streamoff>::const_max ) )
+        {
+            return t.BOOST_IOSTREAMS_PUBSEEKPOS(offset_to_position(off));
+        } else {
+            return t.BOOST_IOSTREAMS_PUBSEEKOFF(off, way, which);
+        }
+    }
+};
+
+template<>
+struct seek_device_impl<two_head> {
+    template<typename T>
+    static std::streampos seek( T& t, stream_offset off,
+                                BOOST_IOS::seekdir way,
+                                BOOST_IOS::openmode which )
+    { return t.seek(off, way, which); }
+};
+
+template<>
+struct seek_device_impl<any_tag> {
+    template<typename T>
+    static std::streampos seek( T& t, stream_offset off,
+                                BOOST_IOS::seekdir way,
+                                BOOST_IOS::openmode )
+    { return t.seek(off, way); }
+};
+
+//------------------Definition of seek_filter_impl----------------------------//
+
+template<typename T>
+struct seek_filter_impl
+    : mpl::if_<
+          is_custom<T>,
+          operations<T>,
+          seek_filter_impl<
+              BOOST_DEDUCED_TYPENAME
+              dispatch<T, two_head, any_tag>::type
+          >
+      >::type
+    { };
+
+template<>
+struct seek_filter_impl<two_head> {
+    template<typename T, typename Device>
+    static std::streampos seek( T& t, Device& d,
+                                stream_offset off,
+                                BOOST_IOS::seekdir way,
+                                BOOST_IOS::openmode which )
+    { return t.seek(d, off, way, which); }
+};
+
+template<>
+struct seek_filter_impl<any_tag> {
+    template<typename T, typename Device>
+    static std::streampos seek( T& t, Device& d,
+                                stream_offset off,
+                                BOOST_IOS::seekdir way,
+                                BOOST_IOS::openmode )
+    { return t.seek(d, off, way); }
+};
+
+} // End namespace detail.
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp>
+
+#endif // #ifndef BOOST_IOSTREAMS_SEEK_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/stream_buffer.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/stream_buffer.hpp
new file mode 100644
index 0000000000..dbcb786c65
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/stream_buffer.hpp
@@ -0,0 +1,116 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_STREAM_BUFFER_HPP_INCLUDED
+#define BOOST_IOSTREAMS_STREAM_BUFFER_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <memory>            // allocator.
+#include <boost/config.hpp>  // BOOST_DEDUCED_TYPENAME.
+#include <boost/iostreams/detail/char_traits.hpp>
+#include <boost/iostreams/detail/config/overload_resolution.hpp>
+#include <boost/iostreams/detail/forward.hpp>
+#include <boost/iostreams/detail/ios.hpp>  // failure, streamsize.
+#include <boost/iostreams/detail/streambuf/direct_streambuf.hpp>
+#include <boost/iostreams/detail/streambuf/indirect_streambuf.hpp>
+#include <boost/iostreams/traits.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>  // MSVC.
+
+namespace boost { namespace iostreams { namespace detail {
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+struct stream_buffer_traits {
+    typedef typename
+            mpl::if_<
+                is_convertible<
+                    BOOST_DEDUCED_TYPENAME category_of<T>::type,
+                    direct_tag
+                >,
+                direct_streambuf<T, Tr>,
+                indirect_streambuf<T, Tr, Alloc, Mode>
+            >::type type;
+};
+
+} } } // End namespaces detail, iostreams, boost
+
+#ifdef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION
+# include <boost/iostreams/detail/broken_overload_resolution/stream_buffer.hpp>
+#else
+
+namespace boost { namespace iostreams {
+
+template< typename T,
+          typename Tr =
+              BOOST_IOSTREAMS_CHAR_TRAITS(
+                  BOOST_DEDUCED_TYPENAME char_type_of<T>::type
+              ),
+          typename Alloc =
+              std::allocator<
+                  BOOST_DEDUCED_TYPENAME char_type_of<T>::type
+              >,
+          typename Mode = BOOST_DEDUCED_TYPENAME mode_of<T>::type >
+class stream_buffer
+    : public detail::stream_buffer_traits<T, Tr, Alloc, Mode>::type
+{
+private:
+    BOOST_STATIC_ASSERT((
+        is_convertible<
+            BOOST_DEDUCED_TYPENAME iostreams::category_of<T>::type, Mode
+        >::value
+    ));
+    typedef typename
+            detail::stream_buffer_traits<
+                T, Tr, Alloc, Mode
+            >::type                           base_type;
+public:
+    typedef typename char_type_of<T>::type    char_type;
+    struct category 
+        : Mode,
+          closable_tag,
+          streambuf_tag
+        { };
+    BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr)
+public:
+    stream_buffer() { }
+    ~stream_buffer()
+    { 
+        try { 
+            if (this->is_open() && this->auto_close()) 
+                this->close(); 
+        } catch (...) { } 
+    }
+    BOOST_IOSTREAMS_FORWARD( stream_buffer, open_impl, T,
+                             BOOST_IOSTREAMS_PUSH_PARAMS,
+                             BOOST_IOSTREAMS_PUSH_ARGS )
+    T& operator*() { return *this->component(); }
+    T* operator->() { return this->component(); }
+private:
+    void open_impl(const T& t BOOST_IOSTREAMS_PUSH_PARAMS())
+        {   // Used for forwarding.
+            if (this->is_open())
+                boost::throw_exception(
+                    BOOST_IOSTREAMS_FAILURE("already open")
+                );
+            base_type::open(t BOOST_IOSTREAMS_PUSH_ARGS());
+        }
+};
+
+} } // End namespaces iostreams, boost.
+
+#endif // #ifdef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp>  // MSVC.
+
+#endif // #ifndef BOOST_IOSTREAMS_STREAM_BUFFER_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/traits.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/traits.hpp
new file mode 100644
index 0000000000..f8d7a3ff5b
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/traits.hpp
@@ -0,0 +1,363 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// 
+// Contains metafunctions char_type_of, category_of and mode_of used for
+// deducing the i/o category and i/o mode of a model of Filter or Device.
+//
+// Also contains several utility metafunctions, functions and macros.
+//
+
+#ifndef BOOST_IOSTREAMS_IO_TRAITS_HPP_INCLUDED
+#define BOOST_IOSTREAMS_IO_TRAITS_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <iosfwd>            // stream types, char_traits.
+#include <boost/config.hpp>  // partial spec, deduced typename.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/categories.hpp>
+#include <boost/iostreams/detail/bool_trait_def.hpp> 
+#include <boost/iostreams/detail/config/wide_streams.hpp>
+#include <boost/iostreams/detail/is_iterator_range.hpp>    
+#include <boost/iostreams/detail/select.hpp>        
+#include <boost/iostreams/detail/select_by_size.hpp>      
+#include <boost/iostreams/detail/wrap_unwrap.hpp>       
+#include <boost/iostreams/traits_fwd.hpp> 
+#include <boost/mpl/bool.hpp>   
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>      
+#include <boost/mpl/int.hpp>  
+#include <boost/mpl/or.hpp>                 
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/ref.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>
+
+namespace boost { namespace iostreams {
+
+//----------Definitions of predicates for streams and stream buffers----------//
+
+#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //--------------------------------//
+
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_istream, std::basic_istream, 2)
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_ostream, std::basic_ostream, 2)
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_iostream, std::basic_iostream, 2)
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_streambuf, std::basic_streambuf, 2)
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_ifstream, std::basic_ifstream, 2)
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_ofstream, std::basic_ofstream, 2)
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_fstream, std::basic_fstream, 2)
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_filebuf, std::basic_filebuf, 2)
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_istringstream, std::basic_istringstream, 3)
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_ostringstream, std::basic_ostringstream, 3)
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_stringstream, std::basic_stringstream, 3)
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_stringbuf, std::basic_stringbuf, 3)
+
+#else // #ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //-----------------------//
+
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_istream, std::istream, 0)
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_ostream, std::ostream, 0)
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_iostream, std::iostream, 0)
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_streambuf, std::streambuf, 0)
+
+#endif // #ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //----------------------//
+
+template<typename T>
+struct is_std_io
+    : mpl::or_< is_istream<T>, is_ostream<T>, is_streambuf<T> >
+    { };
+
+template<typename T>
+struct is_std_file_device
+    : mpl::or_< 
+          is_ifstream<T>, 
+          is_ofstream<T>, 
+          is_fstream<T>, 
+          is_filebuf<T>
+      >
+    { };
+
+template<typename T>
+struct is_std_string_device
+    : mpl::or_< 
+          is_istringstream<T>, 
+          is_ostringstream<T>, 
+          is_stringstream<T>, 
+          is_stringbuf<T>
+      >
+    { };
+
+template<typename Device, typename Tr, typename Alloc>
+struct stream;
+
+template<typename T, typename Tr, typename Alloc, typename Mode>
+class stream_buffer;
+
+template< typename Mode, typename Ch, typename Tr, 
+          typename Alloc, typename Access >
+class filtering_stream;
+
+template< typename Mode, typename Ch, typename Tr, 
+          typename Alloc, typename Access >
+class wfiltering_stream;
+
+template< typename Mode, typename Ch, typename Tr, 
+          typename Alloc, typename Access >
+class filtering_streambuf;
+
+template< typename Mode, typename Ch, typename Tr, 
+          typename Alloc, typename Access >
+class filtering_wstreambuf;
+
+namespace detail {
+
+template<typename T, typename Tr>
+class linked_streambuf;
+
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF( is_boost_stream,
+                                boost::iostreams::stream,
+                                3 )
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF( is_boost_stream_buffer,
+                                boost::iostreams::stream_buffer,
+                                4 )
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF( is_filtering_stream_impl,
+                                boost::iostreams::filtering_stream,
+                                5 )
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF( is_filtering_wstream_impl,
+                                boost::iostreams::wfiltering_stream,
+                                5 )
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF( is_filtering_streambuf_impl,
+                                boost::iostreams::filtering_streambuf,
+                                5 )
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF( is_filtering_wstreambuf_impl,
+                                boost::iostreams::filtering_wstreambuf,
+                                5 )
+BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_linked, linked_streambuf, 2)
+
+template<typename T>
+struct is_filtering_stream
+    : mpl::or_<
+          is_filtering_stream_impl<T>,
+          is_filtering_wstream_impl<T>
+      >
+    { };
+
+template<typename T>
+struct is_filtering_streambuf
+    : mpl::or_<
+          is_filtering_streambuf_impl<T>,
+          is_filtering_wstreambuf_impl<T>
+      >
+    { };
+
+template<typename T>
+struct is_boost
+    : mpl::or_<
+          is_boost_stream<T>, 
+          is_boost_stream_buffer<T>, 
+          is_filtering_stream<T>, 
+          is_filtering_streambuf<T>
+      >
+    { };
+
+} // End namespace detail.
+                    
+//------------------Definitions of char_type_of-------------------------------//
+
+namespace detail {
+
+template<typename T>
+struct member_char_type { typedef typename T::char_type type; };
+
+} // End namespace detail.
+
+# ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //-------------------------------//
+
+template<typename T>
+struct char_type_of 
+    : detail::member_char_type<
+          typename detail::unwrapped_type<T>::type
+      > 
+    { };
+
+# else // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //---------------------//
+
+template<typename T>
+struct char_type_of {
+    typedef typename detail::unwrapped_type<T>::type U;
+    typedef typename 
+            mpl::eval_if<
+                is_std_io<U>,
+                mpl::identity<char>,
+                detail::member_char_type<U>
+            >::type type;
+};
+
+# endif // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //--------------------//
+
+template<typename Iter>
+struct char_type_of< iterator_range<Iter> > {
+    typedef typename iterator_value<Iter>::type type;
+};
+
+
+//------------------Definitions of category_of--------------------------------//
+
+namespace detail {
+
+template<typename T>
+struct member_category { typedef typename T::category type; };
+
+} // End namespace detail.
+
+template<typename T>
+struct category_of {
+    template<typename U>
+    struct member_category { 
+        typedef typename U::category type; 
+    };
+    typedef typename detail::unwrapped_type<T>::type U;
+    typedef typename  
+            mpl::eval_if<
+                mpl::and_<
+                    is_std_io<U>,
+                    mpl::not_< detail::is_boost<U> >
+                >,
+                iostreams::select<  // Disambiguation for Tru64
+                    is_filebuf<U>,        filebuf_tag,
+                    is_ifstream<U>,       ifstream_tag,
+                    is_ofstream<U>,       ofstream_tag,
+                    is_fstream<U>,        fstream_tag,
+                    is_stringbuf<U>,      stringbuf_tag,
+                    is_istringstream<U>,  istringstream_tag,
+                    is_ostringstream<U>,  ostringstream_tag,
+                    is_stringstream<U>,   stringstream_tag,
+                    is_streambuf<U>,      generic_streambuf_tag,
+                    is_iostream<U>,       generic_iostream_tag,
+                    is_istream<U>,        generic_istream_tag, 
+                    is_ostream<U>,        generic_ostream_tag
+                >,
+                detail::member_category<U>
+            >::type type;
+};
+
+// Partial specialization for reference wrappers
+
+template<typename T>
+struct category_of< reference_wrapper<T> >
+    : category_of<T>
+    { };
+
+
+//------------------Definition of get_category--------------------------------//
+
+// 
+// Returns an object of type category_of<T>::type.
+// 
+template<typename T>
+inline typename category_of<T>::type get_category(const T&) 
+{ typedef typename category_of<T>::type category; return category(); }
+
+//------------------Definition of int_type_of---------------------------------//
+
+template<typename T>
+struct int_type_of { 
+#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
+    typedef std::char_traits<
+                BOOST_DEDUCED_TYPENAME char_type_of<T>::type
+            > traits_type;      
+    typedef typename traits_type::int_type type; 
+#else  
+    typedef int                            type; 
+#endif
+};
+
+//------------------Definition of mode_of-------------------------------------//
+
+namespace detail {
+
+template<int N> struct io_mode_impl;
+
+#define BOOST_IOSTREAMS_MODE_HELPER(tag_, id_) \
+    case_<id_> io_mode_impl_helper(tag_); \
+    template<> struct io_mode_impl<id_> { typedef tag_ type; }; \
+    /**/
+BOOST_IOSTREAMS_MODE_HELPER(input, 1)
+BOOST_IOSTREAMS_MODE_HELPER(output, 2)
+BOOST_IOSTREAMS_MODE_HELPER(bidirectional, 3)
+BOOST_IOSTREAMS_MODE_HELPER(input_seekable, 4)
+BOOST_IOSTREAMS_MODE_HELPER(output_seekable, 5)
+BOOST_IOSTREAMS_MODE_HELPER(seekable, 6)
+BOOST_IOSTREAMS_MODE_HELPER(dual_seekable, 7)
+BOOST_IOSTREAMS_MODE_HELPER(bidirectional_seekable, 8)
+BOOST_IOSTREAMS_MODE_HELPER(dual_use, 9)
+#undef BOOST_IOSTREAMS_MODE_HELPER
+
+template<typename T>
+struct io_mode_id {
+    typedef typename category_of<T>::type category;
+    BOOST_SELECT_BY_SIZE(int, value, detail::io_mode_impl_helper(category()));
+};
+
+} // End namespace detail.
+
+template<typename T> // Borland 5.6.4 requires this circumlocution.
+struct mode_of : detail::io_mode_impl< detail::io_mode_id<T>::value > { };
+
+// Partial specialization for reference wrappers
+
+template<typename T>
+struct mode_of< reference_wrapper<T> >
+    : mode_of<T>
+    { };
+
+                    
+//------------------Definition of is_device, is_filter and is_direct----------//
+
+namespace detail {
+
+template<typename T, typename Tag>
+struct has_trait_impl {
+    typedef typename category_of<T>::type category;
+    BOOST_STATIC_CONSTANT(bool, value = (is_convertible<category, Tag>::value));
+};
+
+template<typename T, typename Tag>
+struct has_trait 
+    : mpl::bool_<has_trait_impl<T, Tag>::value>
+    { }; 
+
+} // End namespace detail.
+
+template<typename T>
+struct is_device : detail::has_trait<T, device_tag> { };
+
+template<typename T>
+struct is_filter : detail::has_trait<T, filter_tag> { };
+
+template<typename T>
+struct is_direct : detail::has_trait<T, direct_tag> { };
+                    
+//------------------Definition of BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS----------//
+
+#define BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr) \
+    typedef Tr                              traits_type; \
+    typedef typename traits_type::int_type  int_type; \
+    typedef typename traits_type::off_type  off_type; \
+    typedef typename traits_type::pos_type  pos_type; \
+    /**/
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp>
+
+#endif // #ifndef BOOST_IOSTREAMS_IO_TRAITS_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/traits_fwd.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/traits_fwd.hpp
new file mode 100644
index 0000000000..a3e952623a
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/traits_fwd.hpp
@@ -0,0 +1,111 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Forward declarations of templates defined in traits.hpp.
+
+#ifndef BOOST_IOSTREAMS_IO_TRAITS_FWD_HPP_INCLUDED
+#define BOOST_IOSTREAMS_IO_TRAITS_FWD_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif              
+
+#include <iosfwd> // stream types, char_traits.
+
+namespace boost { namespace iostreams {      
+
+template<typename T>
+struct is_istream;
+
+template<typename T>
+struct is_ostream;
+
+template<typename T>
+struct is_iostream;
+
+template<typename T>
+struct is_streambuf;
+
+template<typename T>
+struct is_istringstream;
+
+template<typename T>
+struct is_ostringstream;
+
+template<typename T>
+struct is_stringstream;
+
+template<typename T>
+struct is_stringbuf;
+
+template<typename T>
+struct is_ifstream;
+
+template<typename T>
+struct is_ofstream;
+
+template<typename T>
+struct is_fstream;
+
+template<typename T>
+struct is_filebuf;
+
+template<typename T>
+struct is_std_io;
+
+template<typename T>
+struct is_std_file_device;
+
+template<typename T>
+struct is_std_string_device;
+
+template<typename T>
+struct char_type_of;
+
+template<typename T>
+struct category_of;
+
+template<typename T>
+struct int_type_of;
+
+template<typename T>
+struct mode_of;
+
+template<typename T>
+struct is_device;
+
+template<typename T>
+struct is_filter;
+
+template<typename T>
+struct is_direct;
+
+namespace detail {
+
+template<typename T>
+struct is_boost_stream;
+
+template<typename T>
+struct is_boost_stream_buffer;
+
+template<typename T>
+struct is_filtering_stream;
+
+template<typename T>
+struct is_filtering_streambuf;
+
+template<typename T>
+struct is_linked;
+
+template<typename T>
+struct is_boost;
+
+} // End namespace detail.
+
+} } // End namespaces iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_IO_TRAITS_FWD_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/include/boost/iostreams/write.hpp b/contrib/restricted/boost/iostreams/include/boost/iostreams/write.hpp
new file mode 100644
index 0000000000..8faf986ae0
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/include/boost/iostreams/write.hpp
@@ -0,0 +1,165 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+#ifndef BOOST_IOSTREAMS_WRITE_HPP_INCLUDED
+#define BOOST_IOSTREAMS_WRITE_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp>  // DEDUCED_TYPENAME, MSVC.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/categories.hpp>
+#include <boost/iostreams/detail/char_traits.hpp>
+#include <boost/iostreams/detail/dispatch.hpp>
+#include <boost/iostreams/detail/ios.hpp>  // streamsize.
+#include <boost/iostreams/detail/streambuf.hpp>
+#include <boost/iostreams/detail/wrap_unwrap.hpp>
+#include <boost/iostreams/operations_fwd.hpp>
+#include <boost/iostreams/traits.hpp>
+#include <boost/mpl/if.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>
+
+namespace boost { namespace iostreams {
+
+namespace detail {
+
+template<typename T> 
+struct write_device_impl;
+
+template<typename T> 
+struct write_filter_impl;
+
+} // End namespace detail.
+
+template<typename T>
+bool put(T& t, typename char_type_of<T>::type c)
+{ return detail::write_device_impl<T>::put(detail::unwrap(t), c); }
+
+template<typename T>
+inline std::streamsize write
+    (T& t, const typename char_type_of<T>::type* s, std::streamsize n)
+{ return detail::write_device_impl<T>::write(detail::unwrap(t), s, n); }
+
+template<typename T, typename Sink>
+inline std::streamsize
+write( T& t, Sink& snk, const typename char_type_of<T>::type* s, 
+       std::streamsize n )
+{ return detail::write_filter_impl<T>::write(detail::unwrap(t), snk, s, n); }
+
+namespace detail {
+
+//------------------Definition of write_device_impl---------------------------//
+
+template<typename T>
+struct write_device_impl
+    : mpl::if_<
+          is_custom<T>,
+          operations<T>,
+          write_device_impl<
+              BOOST_DEDUCED_TYPENAME
+              dispatch<
+                  T, ostream_tag, streambuf_tag, output
+              >::type
+          >
+      >::type
+    { };
+
+template<>
+struct write_device_impl<ostream_tag> {
+    template<typename T>
+    static bool put(T& t, typename char_type_of<T>::type c)
+    {
+        typedef typename char_type_of<T>::type          char_type;
+        typedef BOOST_IOSTREAMS_CHAR_TRAITS(char_type)  traits_type;
+        return !traits_type::eq_int_type( t.rdbuf()->sputc(c),
+                                          traits_type::eof() );
+    }
+
+    template<typename T>
+    static std::streamsize write
+        (T& t, const typename char_type_of<T>::type* s, std::streamsize n)
+    { return t.rdbuf()->sputn(s, n); }
+};
+
+template<>
+struct write_device_impl<streambuf_tag> {
+    template<typename T>
+    static bool put(T& t, typename char_type_of<T>::type c)
+    {
+        typedef typename char_type_of<T>::type          char_type;
+        typedef BOOST_IOSTREAMS_CHAR_TRAITS(char_type)  traits_type;
+        return !traits_type::eq_int_type(t.sputc(c), traits_type::eof());
+    }
+
+    template<typename T>
+    static std::streamsize write
+        (T& t, const typename char_type_of<T>::type* s, std::streamsize n)
+    { return t.sputn(s, n); }
+};
+
+template<>
+struct write_device_impl<output> {
+    template<typename T>
+    static bool put(T& t, typename char_type_of<T>::type c)
+    { return t.write(&c, 1) == 1; }
+
+    template<typename T>
+    static std::streamsize
+    write(T& t, const typename char_type_of<T>::type* s, std::streamsize n)
+    { return t.write(s, n); }
+};
+
+//------------------Definition of write_filter_impl---------------------------//
+
+template<typename T>
+struct write_filter_impl
+    : mpl::if_<
+          is_custom<T>,
+          operations<T>,
+          write_filter_impl<
+              BOOST_DEDUCED_TYPENAME
+              dispatch<
+                  T, multichar_tag, any_tag
+              >::type
+          >
+      >::type
+    { };
+
+template<>
+struct write_filter_impl<multichar_tag> {
+    template<typename T, typename Sink>
+    static std::streamsize
+    write( T& t, Sink& snk, const typename char_type_of<T>::type* s,
+           std::streamsize n )
+    { return t.write(snk, s, n); }
+};
+
+template<>
+struct write_filter_impl<any_tag> {
+    template<typename T, typename Sink>
+    static std::streamsize
+    write( T& t, Sink& snk, const typename char_type_of<T>::type* s,
+           std::streamsize n )
+    {
+        for (std::streamsize off = 0; off < n; ++off)
+            if (!t.put(snk, s[off]))
+                return off;
+        return n;
+    }
+};
+
+} // End namespace detail.
+
+} } // End namespaces iostreams, boost.
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp>
+
+#endif // #ifndef BOOST_IOSTREAMS_WRITE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/iostreams/src/bzip2.cpp b/contrib/restricted/boost/iostreams/src/bzip2.cpp
new file mode 100644
index 0000000000..af80cd2f94
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/src/bzip2.cpp
@@ -0,0 +1,168 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// To configure Boost to work with libbz2, see the 
+// installation instructions here:
+// http://boost.org/libs/iostreams/doc/index.html?path=7
+
+// Define BOOST_IOSTREAMS_SOURCE so that <boost/iostreams/detail/config.hpp> 
+// knows that we are building the library (possibly exporting code), rather 
+// than using it (possibly importing code).
+#define BOOST_IOSTREAMS_SOURCE 
+
+#include <boost/throw_exception.hpp>
+#include <boost/iostreams/detail/config/dyn_link.hpp>
+#include <boost/iostreams/filter/bzip2.hpp> 
+#include "bzlib.h"  // Julian Seward's "bzip.h" header.
+                    // To configure Boost to work with libbz2, see the 
+                    // installation instructions here:
+                    // http://boost.org/libs/iostreams/doc/index.html?path=7
+                    
+namespace boost { namespace iostreams {
+
+namespace bzip2 {
+
+                    // Status codes
+
+const int ok                   = BZ_OK;
+const int run_ok               = BZ_RUN_OK;
+const int flush_ok             = BZ_FLUSH_OK;
+const int finish_ok            = BZ_FINISH_OK;
+const int stream_end           = BZ_STREAM_END;
+const int sequence_error       = BZ_SEQUENCE_ERROR;
+const int param_error          = BZ_PARAM_ERROR;
+const int mem_error            = BZ_MEM_ERROR;
+const int data_error           = BZ_DATA_ERROR;
+const int data_error_magic     = BZ_DATA_ERROR_MAGIC;
+const int io_error             = BZ_IO_ERROR;
+const int unexpected_eof       = BZ_UNEXPECTED_EOF;
+const int outbuff_full         = BZ_OUTBUFF_FULL;
+const int config_error         = BZ_CONFIG_ERROR;
+
+                    // Action codes
+
+const int finish               = BZ_FINISH;
+const int run                  = BZ_RUN;
+
+} // End namespace bzip2. 
+
+//------------------Implementation of bzip2_error-----------------------------//
+                    
+bzip2_error::bzip2_error(int error)
+    : BOOST_IOSTREAMS_FAILURE("bzip2 error"), error_(error) 
+    { }
+
+void bzip2_error::check BOOST_PREVENT_MACRO_SUBSTITUTION(int error)
+{
+    switch (error) {
+    case BZ_OK: 
+    case BZ_RUN_OK: 
+    case BZ_FLUSH_OK:
+    case BZ_FINISH_OK:
+    case BZ_STREAM_END:
+        return;
+    case BZ_MEM_ERROR: 
+        boost::throw_exception(std::bad_alloc());
+    default:
+        boost::throw_exception(bzip2_error(error));
+    }
+}
+
+//------------------Implementation of bzip2_base------------------------------//
+
+namespace detail {
+
+bzip2_base::bzip2_base(const bzip2_params& params)
+    : params_(params), stream_(new bz_stream), ready_(false) 
+    { }
+
+bzip2_base::~bzip2_base() { delete static_cast<bz_stream*>(stream_); }
+
+void bzip2_base::before( const char*& src_begin, const char* src_end,
+                         char*& dest_begin, char* dest_end )
+{
+    bz_stream* s = static_cast<bz_stream*>(stream_);
+    s->next_in = const_cast<char*>(src_begin);
+    s->avail_in = static_cast<unsigned>(src_end - src_begin);
+    s->next_out = reinterpret_cast<char*>(dest_begin);
+    s->avail_out= static_cast<unsigned>(dest_end - dest_begin);
+}
+
+void bzip2_base::after(const char*& src_begin, char*& dest_begin)
+{
+    bz_stream* s = static_cast<bz_stream*>(stream_);
+    src_begin = const_cast<char*>(s->next_in);
+    dest_begin = s->next_out;
+}
+
+int bzip2_base::check_end(const char* src_begin, const char* dest_begin)
+{
+    bz_stream* s = static_cast<bz_stream*>(stream_);
+    if( src_begin == s->next_in &&
+        s->avail_in == 0 &&
+        dest_begin == s->next_out) {
+        return bzip2::unexpected_eof;
+    } else {
+        return bzip2::ok;
+    }
+}
+
+void bzip2_base::end(bool compress)
+{
+    if(!ready_) return;
+    ready_ = false;
+    bz_stream* s = static_cast<bz_stream*>(stream_);
+    bzip2_error::check BOOST_PREVENT_MACRO_SUBSTITUTION(
+        compress ?
+            BZ2_bzCompressEnd(s) : 
+            BZ2_bzDecompressEnd(s)
+    ); 
+}
+
+int bzip2_base::compress(int action)
+{
+    return BZ2_bzCompress(static_cast<bz_stream*>(stream_), action);
+}
+
+int bzip2_base::decompress()
+{
+    return BZ2_bzDecompress(static_cast<bz_stream*>(stream_));
+}
+
+void bzip2_base::do_init
+    ( bool compress, 
+      bzip2::alloc_func /* alloc */, 
+      bzip2::free_func /* free */, 
+      void* derived )
+{
+    bz_stream* s = static_cast<bz_stream*>(stream_);
+
+    // Current interface for customizing memory management 
+    // is non-conforming and has been disabled:
+    //    s->bzalloc = alloc;
+    //    s->bzfree = free;
+        s->bzalloc = 0;
+        s->bzfree = 0;
+    s->opaque = derived;
+    bzip2_error::check BOOST_PREVENT_MACRO_SUBSTITUTION( 
+        compress ?
+            BZ2_bzCompressInit( s,
+                                params_.block_size, 
+                                0, 
+                                params_.work_factor ) :
+            BZ2_bzDecompressInit( s, 
+                                  0, 
+                                  params_.small )
+    );
+    ready_ = true;
+}
+
+} // End namespace detail.
+
+//----------------------------------------------------------------------------//
+
+} } // End namespaces iostreams, boost.
diff --git a/contrib/restricted/boost/iostreams/src/file_descriptor.cpp b/contrib/restricted/boost/iostreams/src/file_descriptor.cpp
new file mode 100644
index 0000000000..288e2c6401
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/src/file_descriptor.cpp
@@ -0,0 +1,619 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// Define BOOST_IOSTREAMS_SOURCE so that <boost/iostreams/detail/config.hpp>
+// knows that we are building the library (possibly exporting code), rather
+// than using it (possibly importing code).
+#define BOOST_IOSTREAMS_SOURCE
+
+#include <cassert>
+#include <cerrno>
+#include <cstdio>                                 // SEEK_SET, etc.
+#include <boost/config.hpp>                       // BOOST_JOIN
+#include <boost/iostreams/detail/error.hpp>
+#include <boost/iostreams/detail/config/dyn_link.hpp>
+#include <boost/iostreams/detail/config/rtl.hpp>  // BOOST_IOSTREAMS_FD_XXX
+#include <boost/iostreams/detail/config/windows_posix.hpp>
+#include <boost/iostreams/detail/system_failure.hpp>
+#include <boost/iostreams/detail/ios.hpp>         // openmodes, failure.
+#include <boost/iostreams/device/file_descriptor.hpp>
+#include <boost/integer_traits.hpp>
+#include <boost/throw_exception.hpp>
+
+// Must come last.
+#include <boost/iostreams/detail/config/disable_warnings.hpp>
+
+    // OS-specific headers for low-level i/o.
+
+#include <fcntl.h>       // file opening flags.
+#include <sys/stat.h>    // file access permissions.
+#ifdef BOOST_IOSTREAMS_WINDOWS
+# include <io.h>         // low-level file i/o.
+# define WINDOWS_LEAN_AND_MEAN
+# include <windows.h>
+# ifndef INVALID_SET_FILE_POINTER
+#  define INVALID_SET_FILE_POINTER ((DWORD)-1)
+# endif
+#else
+# include <sys/types.h>  // mode_t.
+# include <unistd.h>     // low-level file i/o.
+#endif
+
+namespace boost { namespace iostreams {
+
+//------------------Definition of file_descriptor_impl------------------------//
+
+namespace detail {
+
+// Contains the platform dependant implementation
+struct file_descriptor_impl {
+    // Note: These need to match file_desciptor_flags
+    enum flags {
+        never_close = 0,
+        close_on_exit = 1,
+        close_on_close = 2,
+        close_always = 3
+    };
+
+    file_descriptor_impl();
+    ~file_descriptor_impl();
+    void open(file_handle fd, flags);
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    void open(int fd, flags);
+#endif
+    void open(const detail::path&, BOOST_IOS::openmode);
+    bool is_open() const;
+    void close();
+    void close_impl(bool close_flag, bool throw_);
+    std::streamsize read(char* s, std::streamsize n);
+    std::streamsize write(const char* s, std::streamsize n);
+    std::streampos seek(stream_offset off, BOOST_IOS::seekdir way);
+    static file_handle invalid_handle();
+    file_handle  handle_;
+    int          flags_;
+};
+
+//------------------Implementation of file_descriptor_impl--------------------//
+
+file_descriptor_impl::file_descriptor_impl() 
+    : handle_(invalid_handle()), flags_(0) 
+    { }
+
+file_descriptor_impl::~file_descriptor_impl() 
+{ 
+    close_impl(flags_ & close_on_exit, false);
+}
+
+void file_descriptor_impl::open(file_handle fd, flags f)
+{
+    // Using 'close' to close the existing handle so that it will throw an
+    // exception if it fails.
+    //
+    // Only closing after assigning the new handle, so that the class will
+    // take ownership of the handle regardless of whether close throws.
+
+    file_descriptor_impl tmp;
+    tmp.handle_ = handle_;
+    tmp.flags_ = flags_ & close_on_exit ? close_on_close : never_close;
+
+    handle_ = fd;
+    flags_ = f;
+    
+    tmp.close();
+}
+
+#ifdef BOOST_IOSTREAMS_WINDOWS //---------------------------------------------//
+
+void file_descriptor_impl::open(int fd, flags f)
+{ open(reinterpret_cast<file_handle>(_get_osfhandle(fd)), f); }
+
+#endif // #ifdef BOOST_IOSTREAMS_WINDOWS //-----------------------------------//
+
+void file_descriptor_impl::open(const detail::path& p, BOOST_IOS::openmode mode)
+{
+    close_impl(flags_ & close_on_exit, true);
+
+#ifdef BOOST_IOSTREAMS_WINDOWS //---------------------------------------------//
+    DWORD dwDesiredAccess;
+    DWORD dwCreationDisposition;
+    
+    if ( !(mode & (BOOST_IOS::in | BOOST_IOS::out | BOOST_IOS::app)) ||
+            ((mode & BOOST_IOS::trunc) &&
+            ((mode & BOOST_IOS::app) || !(mode & BOOST_IOS::out))) ) {
+        boost::throw_exception(BOOST_IOSTREAMS_FAILURE("bad open mode"));
+    }
+    else if ( mode & BOOST_IOS::in ) {
+        if ( mode & BOOST_IOS::app )
+            {
+            dwCreationDisposition = OPEN_ALWAYS;
+            dwDesiredAccess = 
+                GENERIC_READ | 
+                FILE_APPEND_DATA |
+                FILE_WRITE_ATTRIBUTES |
+                FILE_WRITE_EA |
+                STANDARD_RIGHTS_WRITE |
+                SYNCHRONIZE;
+            }
+        else if ( mode & BOOST_IOS::trunc )
+            {
+            dwCreationDisposition = CREATE_ALWAYS;
+            dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
+            }
+        else if ( mode & BOOST_IOS::out )
+            {
+            dwCreationDisposition = OPEN_EXISTING;
+            dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
+            }
+        else
+            {
+            dwCreationDisposition = OPEN_EXISTING;
+            dwDesiredAccess = GENERIC_READ;
+            }
+    }
+    else {
+        if ( mode & BOOST_IOS::app )
+            {
+            dwCreationDisposition = OPEN_ALWAYS;
+            dwDesiredAccess = 
+                FILE_APPEND_DATA |
+                FILE_WRITE_ATTRIBUTES |
+                FILE_WRITE_EA |
+                STANDARD_RIGHTS_WRITE |
+                SYNCHRONIZE;
+            }
+        else
+            {
+            dwCreationDisposition = CREATE_ALWAYS;
+            dwDesiredAccess = GENERIC_WRITE;
+            }
+    }
+    
+
+    HANDLE handle = p.is_wide() ?
+        ::CreateFileW( p.c_wstr(),
+                       dwDesiredAccess,
+                       FILE_SHARE_READ | FILE_SHARE_WRITE,
+                       NULL,                   // lpSecurityAttributes
+                       dwCreationDisposition,
+                       FILE_ATTRIBUTE_NORMAL,
+                       NULL ) :                // hTemplateFile
+        ::CreateFileA( p.c_str(),
+                       dwDesiredAccess,
+                       FILE_SHARE_READ | FILE_SHARE_WRITE,
+                       NULL,                   // lpSecurityAttributes
+                       dwCreationDisposition,
+                       FILE_ATTRIBUTE_NORMAL,
+                       NULL );                 // hTemplateFile
+    if (handle != INVALID_HANDLE_VALUE) {
+        handle_ = handle;
+        flags_ = close_always;
+    } else {
+        flags_ = 0;
+        throw_system_failure("failed opening file");
+    }
+#else // #ifdef BOOST_IOSTREAMS_WINDOWS //------------------------------------//
+
+        // Calculate oflag argument to open.
+
+    int oflag = 0;
+    if ( !(mode & (BOOST_IOS::in | BOOST_IOS::out | BOOST_IOS::app)) ||
+            ((mode & BOOST_IOS::trunc) &&
+            ((mode & BOOST_IOS::app) || !(mode & BOOST_IOS::out))) ) {
+        boost::throw_exception(BOOST_IOSTREAMS_FAILURE("bad open mode"));
+    }
+    else if ( mode & BOOST_IOS::in ) {
+        if ( mode & BOOST_IOS::app )
+            oflag |= O_CREAT | O_APPEND | O_RDWR;
+        else if ( mode & BOOST_IOS::trunc )
+            oflag |= O_CREAT | O_TRUNC | O_RDWR;
+        else if ( mode & BOOST_IOS::out )
+            oflag |= O_RDWR;
+        else
+            oflag |= O_RDONLY;
+    }
+    else {
+        if ( mode & BOOST_IOS::app )
+            oflag |= O_CREAT | O_APPEND | O_WRONLY;
+        else
+            oflag |= O_CREAT | O_TRUNC | O_WRONLY;
+    }
+    #ifdef _LARGEFILE64_SOURCE
+        oflag |= O_LARGEFILE;
+    #endif
+
+        // Calculate pmode argument to open.
+
+    mode_t pmode = S_IRUSR | S_IWUSR |
+                   S_IRGRP | S_IWGRP |
+                   S_IROTH | S_IWOTH;
+
+        // Open file.
+
+    int fd = BOOST_IOSTREAMS_FD_OPEN(p.c_str(), oflag, pmode);
+    if (fd == -1) {
+        boost::throw_exception(system_failure("failed opening file"));
+    } else {
+        if ( mode & BOOST_IOS::ate ) {
+            if (BOOST_IOSTREAMS_FD_SEEK(fd, 0, SEEK_END) == -1) {
+                BOOST_IOSTREAMS_FD_CLOSE(fd);
+                boost::throw_exception(system_failure("failed opening file"));
+            }
+        }
+        handle_ = fd;
+        flags_ = close_always;
+    }
+#endif // #ifndef BOOST_IOSTREAMS_WINDOWS //----------------------------------//
+}
+
+bool file_descriptor_impl::is_open() const
+{ return handle_ != invalid_handle(); }
+
+void file_descriptor_impl::close()
+{
+    close_impl((flags_ & close_on_close) != 0, true);
+}
+
+void file_descriptor_impl::close_impl(bool close_flag, bool throw_) {
+    if (handle_ != invalid_handle()) {
+        if (close_flag) {
+            bool success = 
+                #ifdef BOOST_IOSTREAMS_WINDOWS
+                    ::CloseHandle(handle_) == 1;
+                #else
+                    BOOST_IOSTREAMS_FD_CLOSE(handle_) != -1;
+                #endif
+            if (!success && throw_)
+                throw_system_failure("failed closing file");
+        }
+        handle_ = invalid_handle();
+        flags_ = 0;
+    }
+}
+
+std::streamsize file_descriptor_impl::read(char* s, std::streamsize n)
+{
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    DWORD result;
+    if (!::ReadFile(handle_, s, static_cast<DWORD>(n), &result, NULL))
+    {
+        // report EOF if the write-side of a pipe has been closed
+        if (GetLastError() == ERROR_BROKEN_PIPE)
+        {
+            result = 0;
+        }
+        else
+            throw_system_failure("failed reading");
+    }
+    return result == 0 ? -1 : static_cast<std::streamsize>(result);
+#else // #ifdef BOOST_IOSTREAMS_WINDOWS
+    errno = 0;
+    std::streamsize result = BOOST_IOSTREAMS_FD_READ(handle_, s, n);
+    if (errno != 0)
+        throw_system_failure("failed reading");
+    return result == 0 ? -1 : result;
+#endif // #ifdef BOOST_IOSTREAMS_WINDOWS
+}
+
+std::streamsize file_descriptor_impl::write(const char* s, std::streamsize n)
+{
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    DWORD ignore;
+    if (!::WriteFile(handle_, s, static_cast<DWORD>(n), &ignore, NULL))
+        throw_system_failure("failed writing");
+    return n;
+#else // #ifdef BOOST_IOSTREAMS_WINDOWS
+    int amt = BOOST_IOSTREAMS_FD_WRITE(handle_, s, n);
+    if (amt < n) // Handles blocking fd's only.
+        throw_system_failure("failed writing");
+    return n;
+#endif // #ifdef BOOST_IOSTREAMS_WINDOWS
+}
+
+std::streampos file_descriptor_impl::seek
+    (stream_offset off, BOOST_IOS::seekdir way)
+{
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    LONG lDistanceToMove = static_cast<LONG>(off & 0xffffffff);
+    LONG lDistanceToMoveHigh = static_cast<LONG>(off >> 32);
+    DWORD dwResultLow =
+        ::SetFilePointer( handle_,
+                          lDistanceToMove,
+                          &lDistanceToMoveHigh,
+                          way == BOOST_IOS::beg ?
+                              FILE_BEGIN :
+                              way == BOOST_IOS::cur ?
+                                FILE_CURRENT :
+                                FILE_END );
+    if ( dwResultLow == INVALID_SET_FILE_POINTER &&
+         ::GetLastError() != NO_ERROR )
+    {
+        boost::throw_exception(system_failure("failed seeking"));
+    } else {
+       return offset_to_position(
+                  (stream_offset(lDistanceToMoveHigh) << 32) + dwResultLow
+              );
+    }
+#else // #ifdef BOOST_IOSTREAMS_WINDOWS
+    if ( off > integer_traits<BOOST_IOSTREAMS_FD_OFFSET>::const_max ||
+         off < integer_traits<BOOST_IOSTREAMS_FD_OFFSET>::const_min )
+    {
+        boost::throw_exception(BOOST_IOSTREAMS_FAILURE("bad offset"));
+    }
+    stream_offset result =
+        BOOST_IOSTREAMS_FD_SEEK(
+            handle_,
+            static_cast<BOOST_IOSTREAMS_FD_OFFSET>(off),
+            ( way == BOOST_IOS::beg ?
+                  SEEK_SET :
+                  way == BOOST_IOS::cur ?
+                      SEEK_CUR :
+                      SEEK_END ) 
+        );
+    if (result == -1)
+        boost::throw_exception(system_failure("failed seeking"));
+    return offset_to_position(result);
+#endif // #ifdef BOOST_IOSTREAMS_WINDOWS
+}
+
+// Returns the value stored in a file_handle variable when no file is open
+file_handle file_descriptor_impl::invalid_handle()
+{
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    return INVALID_HANDLE_VALUE;
+#else
+    return -1;
+#endif
+}
+
+} // End namespace detail.
+
+//------------------Implementation of file_descriptor-------------------------//
+
+file_descriptor::file_descriptor() : pimpl_(new impl_type) { }
+
+file_descriptor::file_descriptor(handle_type fd, file_descriptor_flags f)
+    : pimpl_(new impl_type)
+{ open(fd, f); }
+
+#if defined(BOOST_IOSTREAMS_USE_DEPRECATED)
+file_descriptor::file_descriptor(handle_type fd, bool close_on_exit)
+    : pimpl_(new impl_type)
+{ open(fd, close_on_exit); }
+#endif
+
+#ifdef BOOST_IOSTREAMS_WINDOWS //---------------------------------------------//
+
+file_descriptor::file_descriptor(int fd, file_descriptor_flags f)
+    : pimpl_(new impl_type)
+{ open(fd, f); }
+
+#if defined(BOOST_IOSTREAMS_USE_DEPRECATED)
+file_descriptor::file_descriptor(int fd, bool close_on_exit)
+    : pimpl_(new impl_type)
+{ open(fd, close_on_exit); }
+#endif
+
+#endif // #ifdef BOOST_IOSTREAMS_WINDOWS //-----------------------------------//
+
+file_descriptor::file_descriptor( const std::string& path,
+                                  BOOST_IOS::openmode mode )
+    : pimpl_(new impl_type)
+{ open(path, mode); }
+
+file_descriptor::file_descriptor( const char* path,
+                                  BOOST_IOS::openmode mode )
+    : pimpl_(new impl_type)
+{ open(path, mode); }
+
+file_descriptor::file_descriptor(const file_descriptor& other) 
+    : pimpl_(other.pimpl_) 
+    { }
+
+void file_descriptor::open(handle_type fd, file_descriptor_flags f)
+{ pimpl_->open(fd, static_cast<detail::file_descriptor_impl::flags>(f)); }
+
+#if defined(BOOST_IOSTREAMS_USE_DEPRECATED)
+void file_descriptor::open(handle_type fd, bool close_on_exit)
+{ pimpl_->open(fd, close_on_exit ?
+    detail::file_descriptor_impl::close_always :
+    detail::file_descriptor_impl::close_on_close); }
+#endif
+
+#ifdef BOOST_IOSTREAMS_WINDOWS //---------------------------------------------//
+
+void file_descriptor::open(int fd, file_descriptor_flags f)
+{ pimpl_->open(fd, static_cast<detail::file_descriptor_impl::flags>(f)); }
+
+#if defined(BOOST_IOSTREAMS_USE_DEPRECATED)
+void file_descriptor::open(int fd, bool close_on_exit)
+{ pimpl_->open(fd, close_on_exit ?
+    detail::file_descriptor_impl::close_always :
+    detail::file_descriptor_impl::close_on_close); }
+#endif
+
+#endif // #ifdef BOOST_IOSTREAMS_WINDOWS //-----------------------------------//
+
+void file_descriptor::open(const std::string& path, BOOST_IOS::openmode mode)
+{ open(detail::path(path), mode); }
+
+void file_descriptor::open(const char* path, BOOST_IOS::openmode mode)
+{ open(detail::path(path), mode); }
+
+bool file_descriptor::is_open() const { return pimpl_->is_open(); }
+
+void file_descriptor::close() { pimpl_->close(); }
+
+std::streamsize file_descriptor::read(char_type* s, std::streamsize n)
+{ return pimpl_->read(s, n); }
+
+std::streamsize file_descriptor::write(const char_type* s, std::streamsize n)
+{ return pimpl_->write(s, n); }
+
+std::streampos file_descriptor::seek(stream_offset off, BOOST_IOS::seekdir way)
+{ return pimpl_->seek(off, way); }
+
+detail::file_handle file_descriptor::handle() const { return pimpl_->handle_; }
+
+void file_descriptor::init() { pimpl_.reset(new impl_type); }
+
+void file_descriptor::open(
+    const detail::path& path, 
+    BOOST_IOS::openmode mode, 
+    BOOST_IOS::openmode base )
+{
+    mode |= base;
+    pimpl_->open(path, mode);
+}
+                    
+//------------------Implementation of file_descriptor_source------------------//
+
+file_descriptor_source::file_descriptor_source(
+    handle_type fd, file_descriptor_flags f)
+{ open(fd, f); }
+
+#if defined(BOOST_IOSTREAMS_USE_DEPRECATED)
+file_descriptor_source::file_descriptor_source(
+    handle_type fd, bool close_on_exit)
+{ open(fd, close_on_exit); }
+#endif
+
+#ifdef BOOST_IOSTREAMS_WINDOWS //---------------------------------------------//
+
+file_descriptor_source::file_descriptor_source(int fd, file_descriptor_flags f)
+{ open(fd, f); }
+
+#if defined(BOOST_IOSTREAMS_USE_DEPRECATED)
+file_descriptor_source::file_descriptor_source(int fd, bool close_on_exit)
+{ open(fd, close_on_exit); }
+#endif
+
+#endif // #ifdef BOOST_IOSTREAMS_WINDOWS //-----------------------------------//
+
+file_descriptor_source::file_descriptor_source(
+    const std::string& path, BOOST_IOS::openmode mode)
+{ open(path, mode); }
+
+file_descriptor_source::file_descriptor_source(
+    const char* path, BOOST_IOS::openmode mode)
+{ open(path, mode); }
+
+file_descriptor_source::file_descriptor_source(
+    const file_descriptor_source& other) 
+        : file_descriptor(static_cast<const file_descriptor&>(other)) 
+    { }
+
+void file_descriptor_source::open(handle_type fd, file_descriptor_flags f)
+{ file_descriptor::open(fd, f);  }
+
+#if defined(BOOST_IOSTREAMS_USE_DEPRECATED)
+void file_descriptor_source::open(handle_type fd, bool close_on_exit)
+{ file_descriptor::open(fd, close_on_exit); }
+#endif
+
+#ifdef BOOST_IOSTREAMS_WINDOWS //---------------------------------------------//
+
+void file_descriptor_source::open(int fd, file_descriptor_flags f)
+{ file_descriptor::open(fd, f); }
+
+#if defined(BOOST_IOSTREAMS_USE_DEPRECATED)
+void file_descriptor_source::open(int fd, bool close_on_exit)
+{ file_descriptor::open(fd, close_on_exit); }
+#endif
+
+#endif // #ifdef BOOST_IOSTREAMS_WINDOWS //-----------------------------------//
+
+void file_descriptor_source::open(
+    const std::string& path, BOOST_IOS::openmode mode)
+{ open(detail::path(path), mode); }
+
+void file_descriptor_source::open(
+    const char* path, BOOST_IOS::openmode mode)
+{ open(detail::path(path), mode); }
+
+void file_descriptor_source::open(
+    const detail::path& path, BOOST_IOS::openmode mode)
+{ 
+    if (mode & (BOOST_IOS::out | BOOST_IOS::trunc))
+        boost::throw_exception(BOOST_IOSTREAMS_FAILURE("invalid mode"));
+    file_descriptor::open(path, mode, BOOST_IOS::in); 
+}
+                    
+//------------------Implementation of file_descriptor_sink--------------------//
+
+file_descriptor_sink::file_descriptor_sink(
+    handle_type fd, file_descriptor_flags f)
+{ open(fd, f); }
+
+#if defined(BOOST_IOSTREAMS_USE_DEPRECATED)
+file_descriptor_sink::file_descriptor_sink(
+    handle_type fd, bool close_on_exit)
+{ open(fd, close_on_exit); }
+#endif
+
+#ifdef BOOST_IOSTREAMS_WINDOWS //---------------------------------------------//
+
+file_descriptor_sink::file_descriptor_sink(int fd, file_descriptor_flags f)
+{ open(fd, f); }
+
+#if defined(BOOST_IOSTREAMS_USE_DEPRECATED)
+file_descriptor_sink::file_descriptor_sink(int fd, bool close_on_exit)
+{ open(fd, close_on_exit); }
+#endif
+
+#endif // #ifdef BOOST_IOSTREAMS_WINDOWS //-----------------------------------//
+
+file_descriptor_sink::file_descriptor_sink(
+    const std::string& path, BOOST_IOS::openmode mode)
+{ open(path, mode); }
+
+file_descriptor_sink::file_descriptor_sink(
+    const char* path, BOOST_IOS::openmode mode)
+{ open(path, mode); }
+
+file_descriptor_sink::file_descriptor_sink(const file_descriptor_sink& other) 
+    : file_descriptor(static_cast<const file_descriptor&>(other)) 
+    { }
+
+void file_descriptor_sink::open(handle_type fd, file_descriptor_flags f)
+{ file_descriptor::open(fd, f);  }
+
+#if defined(BOOST_IOSTREAMS_USE_DEPRECATED)
+void file_descriptor_sink::open(handle_type fd, bool close_on_exit)
+{ file_descriptor::open(fd, close_on_exit); }
+#endif
+
+#ifdef BOOST_IOSTREAMS_WINDOWS //---------------------------------------------//
+
+void file_descriptor_sink::open(int fd, file_descriptor_flags f)
+{ file_descriptor::open(fd, f); }
+
+#if defined(BOOST_IOSTREAMS_USE_DEPRECATED)
+void file_descriptor_sink::open(int fd, bool close_on_exit)
+{ file_descriptor::open(fd, close_on_exit); }
+#endif
+
+#endif // #ifdef BOOST_IOSTREAMS_WINDOWS //-----------------------------------//
+
+void file_descriptor_sink::open(
+    const std::string& path, BOOST_IOS::openmode mode)
+{ open(detail::path(path), mode); }
+
+void file_descriptor_sink::open(
+    const char* path, BOOST_IOS::openmode mode)
+{ open(detail::path(path), mode); }
+
+void file_descriptor_sink::open(
+    const detail::path& path, BOOST_IOS::openmode mode)
+{ 
+    if (mode & BOOST_IOS::in)
+        boost::throw_exception(BOOST_IOSTREAMS_FAILURE("invalid mode"));
+    file_descriptor::open(path, mode, BOOST_IOS::out); 
+}
+
+#include <boost/iostreams/detail/config/enable_warnings.hpp>
+
+} } // End namespaces iostreams, boost.
diff --git a/contrib/restricted/boost/iostreams/src/gzip.cpp b/contrib/restricted/boost/iostreams/src/gzip.cpp
new file mode 100644
index 0000000000..94830e5b8c
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/src/gzip.cpp
@@ -0,0 +1,174 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// To configure Boost to work with libbz2, see the 
+// installation instructions here:
+// http://boost.org/libs/iostreams/doc/index.html?path=7
+
+// Define BOOST_IOSTREAMS_SOURCE so that <boost/iostreams/detail/config.hpp> 
+// knows that we are building the library (possibly exporting code), rather 
+// than using it (possibly importing code).
+#define BOOST_IOSTREAMS_SOURCE 
+
+#include <boost/iostreams/detail/config/dyn_link.hpp>
+#include <boost/iostreams/filter/gzip.hpp>
+#include <boost/throw_exception.hpp>
+
+namespace boost { namespace iostreams {
+
+//------------------Implementation of gzip_header-----------------------------//
+
+namespace detail {
+
+void gzip_header::process(char c)
+{
+    uint8_t value = static_cast<uint8_t>(c);
+    switch (state_) {
+    case s_id1:
+        if (value != gzip::magic::id1)
+            boost::throw_exception(gzip_error(gzip::bad_header));
+        state_ = s_id2;
+        break;
+    case s_id2:
+        if (value != gzip::magic::id2)
+            boost::throw_exception(gzip_error(gzip::bad_header));
+        state_ = s_cm;
+        break;
+    case s_cm:
+        if (value != gzip::method::deflate)
+            boost::throw_exception(gzip_error(gzip::bad_method));
+        state_ = s_flg;
+        break;
+    case s_flg:
+        flags_ = value;
+        state_ = s_mtime;
+        break;
+    case s_mtime:
+        mtime_ += value << (offset_ * 8);
+        if (offset_ == 3) {
+            state_ = s_xfl;
+            offset_ = 0;
+        } else {
+            ++offset_;
+        }
+        break;
+    case s_xfl:
+        state_ = s_os;
+        break;
+    case s_os:
+        os_ = value;
+        if (flags_ & gzip::flags::extra) {
+            state_ = s_xlen;
+        } else if (flags_ & gzip::flags::name) {
+            state_ = s_name;
+        } else if (flags_ & gzip::flags::comment) {
+            state_ = s_comment;
+        } else if (flags_ & gzip::flags::header_crc) {
+            state_ = s_hcrc;
+        } else {
+            state_ = s_done;
+        }
+        break;
+    case s_xlen:
+        xlen_ += value << (offset_ * 8);
+        if (offset_ == 1) {
+            state_ = s_extra;
+            offset_ = 0;
+        } else {
+            ++offset_;
+        }
+        break;
+    case s_extra:
+        if (--xlen_ == 0) {
+            if (flags_ & gzip::flags::name) {
+                state_ = s_name;
+            } else if (flags_ & gzip::flags::comment) {
+                state_ = s_comment;
+            } else if (flags_ & gzip::flags::header_crc) {
+                state_ = s_hcrc;
+            } else {
+                state_ = s_done;
+            }
+        }
+        break;
+    case s_name:
+        if (c != 0) {
+            file_name_ += c;
+        } else if (flags_ & gzip::flags::comment) {
+            state_ = s_comment;
+        } else if (flags_ & gzip::flags::header_crc) {
+            state_ = s_hcrc;
+        } else {
+            state_ = s_done;
+        }
+        break;
+    case s_comment:
+        if (c != 0) {
+            comment_ += c;
+        } else if (flags_ & gzip::flags::header_crc) {
+            state_ = s_hcrc;
+        } else {
+            state_ = s_done;
+        }
+        break;
+    case s_hcrc:
+        if (offset_ == 1) {
+            state_ = s_done;
+            offset_ = 0;
+        } else {
+            ++offset_;
+        }
+        break;
+    default:
+        BOOST_ASSERT(0);
+    }
+}
+
+void gzip_header::reset()
+{
+    file_name_.clear();
+    comment_.clear();
+    os_ = flags_ = offset_ = xlen_ = 0;
+    mtime_ = 0;
+    state_ = s_id1;
+}
+
+//------------------Implementation of gzip_footer-----------------------------//
+
+void gzip_footer::process(char c)
+{
+    uint8_t value = static_cast<uint8_t>(c);
+    if (state_ == s_crc) {
+        crc_ += value << (offset_ * 8);
+        if (offset_ == 3) {
+            state_ = s_isize;
+            offset_ = 0;
+        } else {
+            ++offset_;
+        }
+    } else if (state_ == s_isize) {
+        isize_ += value << (offset_ * 8);
+        if (offset_ == 3) {
+            state_ = s_done;
+            offset_ = 0;
+        } else {
+            ++offset_;
+        }
+    } else {
+        BOOST_ASSERT(0);
+    }
+}
+
+void gzip_footer::reset()
+{
+    crc_ = isize_ = offset_ = 0;
+    state_ = s_crc;
+}
+
+} // End namespace boost::iostreams::detail.
+
+} } // End namespaces iostreams, boost.
diff --git a/contrib/restricted/boost/iostreams/src/lzma.cpp b/contrib/restricted/boost/iostreams/src/lzma.cpp
new file mode 100644
index 0000000000..5d7bb3cfbd
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/src/lzma.cpp
@@ -0,0 +1,147 @@
+// (C) Copyright Milan Svoboda 2008.
+// Originally developed under the fusecompress project.
+// Based on bzip2.cpp by:
+// (C) Copyright Jonathan Turkanis 2003.
+// 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/iostreams for documentation.
+
+// Define BOOST_IOSTREAMS_SOURCE so that <boost/iostreams/detail/config.hpp>
+// knows that we are building the library (possibly exporting code), rather
+// than using it (possibly importing code).
+#define BOOST_IOSTREAMS_SOURCE
+
+#include <lzma.h>
+
+#include <boost/throw_exception.hpp>
+#include <boost/iostreams/detail/config/dyn_link.hpp>
+#include <boost/iostreams/filter/lzma.hpp>
+
+namespace boost { namespace iostreams {
+
+namespace lzma {
+
+                    // Compression levels
+
+const uint32_t no_compression       = 0;
+const uint32_t best_speed           = 1;
+const uint32_t best_compression     = 9;
+const uint32_t default_compression  = 2;
+
+                    // Status codes
+
+const int okay                 = LZMA_OK;
+const int stream_end           = LZMA_STREAM_END;
+const int unsupported_check    = LZMA_UNSUPPORTED_CHECK;
+const int mem_error            = LZMA_MEM_ERROR;
+const int options_error        = LZMA_OPTIONS_ERROR;
+const int data_error           = LZMA_DATA_ERROR;
+const int buf_error            = LZMA_BUF_ERROR;
+const int prog_error           = LZMA_PROG_ERROR;
+
+                    // Flush codes
+
+const int finish               = LZMA_FINISH;
+const int full_flush           = LZMA_FULL_FLUSH;
+const int sync_flush           = LZMA_SYNC_FLUSH;
+const int run                  = LZMA_RUN;
+
+                    // Code for current OS
+
+} // End namespace lzma.
+
+//------------------Implementation of lzma_error------------------------------//
+
+lzma_error::lzma_error(int error)
+    : BOOST_IOSTREAMS_FAILURE("lzma error"), error_(error)
+    { }
+
+void lzma_error::check BOOST_PREVENT_MACRO_SUBSTITUTION(int error)
+{
+    switch (error) {
+    case LZMA_OK:
+    case LZMA_STREAM_END:
+        return;
+    case LZMA_MEM_ERROR:
+        boost::throw_exception(std::bad_alloc());
+    default:
+        boost::throw_exception(lzma_error(error));
+    }
+}
+
+//------------------Implementation of lzma_base-------------------------------//
+
+namespace detail {
+
+lzma_base::lzma_base()
+    : stream_(new lzma_stream)
+    { }
+
+lzma_base::~lzma_base() { delete static_cast<lzma_stream*>(stream_); }
+
+void lzma_base::before( const char*& src_begin, const char* src_end,
+                        char*& dest_begin, char* dest_end )
+{
+    lzma_stream* s = static_cast<lzma_stream*>(stream_);
+    s->next_in = reinterpret_cast<uint8_t*>(const_cast<char*>(src_begin));
+    s->avail_in = static_cast<size_t>(src_end - src_begin);
+    s->next_out = reinterpret_cast<uint8_t*>(dest_begin);
+    s->avail_out= static_cast<size_t>(dest_end - dest_begin);
+}
+
+void lzma_base::after(const char*& src_begin, char*& dest_begin, bool)
+{
+    lzma_stream* s = static_cast<lzma_stream*>(stream_);
+    src_begin = const_cast<const char*>(reinterpret_cast<const char*>(s->next_in));
+    dest_begin = reinterpret_cast<char*>(s->next_out);
+}
+
+int lzma_base::deflate(int action)
+{
+    return lzma_code(static_cast<lzma_stream*>(stream_), static_cast<lzma_action>(action));
+}
+
+int lzma_base::inflate(int action)
+{
+    return lzma_code(static_cast<lzma_stream*>(stream_), static_cast<lzma_action>(action));
+}
+
+void lzma_base::reset(bool compress, bool realloc)
+{
+    lzma_stream* s = static_cast<lzma_stream*>(stream_);
+    lzma_end(s);
+    if (realloc)
+    {
+        memset(s, 0, sizeof(*s));
+
+        lzma_error::check BOOST_PREVENT_MACRO_SUBSTITUTION(
+            compress ?
+                lzma_easy_encoder(s, level, LZMA_CHECK_CRC32) :
+                lzma_stream_decoder(s, 100 * 1024 * 1024, LZMA_CONCATENATED)
+        );
+    }
+}
+
+void lzma_base::do_init
+    ( const lzma_params& p, bool compress,
+      lzma::alloc_func, lzma::free_func,
+      void* )
+{
+    lzma_stream* s = static_cast<lzma_stream*>(stream_);
+
+    memset(s, 0, sizeof(*s));
+
+    level = p.level;
+    lzma_error::check BOOST_PREVENT_MACRO_SUBSTITUTION(
+        compress ?
+            lzma_easy_encoder(s, p.level, LZMA_CHECK_CRC32) :
+            lzma_stream_decoder(s, 100 * 1024 * 1024, LZMA_CONCATENATED)
+    );
+}
+
+} // End namespace detail.
+
+//----------------------------------------------------------------------------//
+
+} } // End namespaces iostreams, boost.
diff --git a/contrib/restricted/boost/iostreams/src/mapped_file.cpp b/contrib/restricted/boost/iostreams/src/mapped_file.cpp
new file mode 100644
index 0000000000..e345086a2d
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/src/mapped_file.cpp
@@ -0,0 +1,498 @@
+// (C) Copyright Craig Henderson 2002 'boost/memmap.hpp' from sandbox
+// (C) Copyright Jonathan Turkanis 2004.
+// (C) Copyright Jonathan Graehl 2004.
+// (C) Copyright Jorge Lodos 2008.
+// 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.)
+
+// Define BOOST_IOSTREAMS_SOURCE so that <boost/iostreams/detail/config.hpp>
+// knows that we are building the library (possibly exporting code), rather
+// than using it (possibly importing code).
+#define BOOST_IOSTREAMS_SOURCE
+
+#include <cassert>
+#include <boost/iostreams/detail/config/rtl.hpp>
+#include <boost/iostreams/detail/config/windows_posix.hpp>
+#include <boost/iostreams/detail/file_handle.hpp>
+#include <boost/iostreams/detail/system_failure.hpp>
+#include <boost/iostreams/device/mapped_file.hpp>
+#include <boost/throw_exception.hpp>
+
+#ifdef BOOST_IOSTREAMS_WINDOWS
+# ifndef WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN  // Exclude rarely-used stuff from Windows headers
+# endif
+# include <windows.h>
+#else
+# include <errno.h>
+# include <fcntl.h>
+# include <sys/mman.h>      // mmap, munmap.
+# include <sys/stat.h>
+# include <sys/types.h>     // struct stat.
+# include <unistd.h>        // sysconf.
+#endif
+
+namespace boost { namespace iostreams {
+
+namespace detail {
+
+// Class containing the platform-sepecific implementation
+// Invariant: The members params_, data_, size_, handle_ (and mapped_handle_ 
+// on Windows) either
+//    - all have default values (or INVALID_HANDLE_VALUE for
+//      Windows handles), or
+//    - all have values reflecting a successful mapping.
+// In the first case, error_ may be true, reflecting a recent unsuccessful
+// open or close attempt; in the second case, error_ is always false.
+class mapped_file_impl {
+public:
+    typedef mapped_file_source::size_type   size_type;
+    typedef mapped_file_source::param_type  param_type;
+    typedef mapped_file_source::mapmode     mapmode;
+    BOOST_STATIC_CONSTANT(
+        size_type, max_length =  mapped_file_source::max_length);
+    mapped_file_impl();
+    ~mapped_file_impl();
+    void open(param_type p);
+    bool is_open() const { return data_ != 0; }
+    void close();
+    bool error() const { return error_; }
+    mapmode flags() const { return params_.flags; }
+    std::size_t size() const { return static_cast<std::size_t>(size_); }
+    char* data() const { return data_; }
+    void resize(stream_offset new_size);
+    static int alignment();
+private:
+    void open_file(param_type p);
+    void try_map_file(param_type p);
+    void map_file(param_type& p);
+    bool unmap_file();
+    void clear(bool error);
+    void cleanup_and_throw(const char* msg);
+    param_type     params_;
+    char*          data_;
+    stream_offset  size_;
+    file_handle    handle_;
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    file_handle    mapped_handle_;
+#endif
+    bool           error_;
+};
+
+mapped_file_impl::mapped_file_impl() { clear(false); }
+
+mapped_file_impl::~mapped_file_impl() 
+{ try { close(); } catch (...) { } }
+
+void mapped_file_impl::open(param_type p)
+{
+    if (is_open())
+        boost::throw_exception(BOOST_IOSTREAMS_FAILURE("file already open"));
+    p.normalize();
+    open_file(p);
+    map_file(p);  // May modify p.hint
+    params_ = p;
+}
+
+void mapped_file_impl::close()
+{
+    if (data_ == 0)
+        return;
+    bool error = false;
+    error = !unmap_file() || error;
+    error = 
+        #ifdef BOOST_IOSTREAMS_WINDOWS
+            !::CloseHandle(handle_) 
+        #else
+            ::close(handle_) != 0 
+        #endif
+            || error;
+    clear(error);
+    if (error)
+        throw_system_failure("failed closing mapped file");
+}
+
+void mapped_file_impl::resize(stream_offset new_size)
+{
+    if (!is_open())
+        boost::throw_exception(BOOST_IOSTREAMS_FAILURE("file is closed"));
+    if (flags() & mapped_file::priv)
+        boost::throw_exception(
+            BOOST_IOSTREAMS_FAILURE("can't resize private mapped file")
+        );
+    if (!(flags() & mapped_file::readwrite))
+        boost::throw_exception(
+            BOOST_IOSTREAMS_FAILURE("can't resize readonly mapped file")
+        );
+    if (params_.offset >= new_size)
+        boost::throw_exception(
+            BOOST_IOSTREAMS_FAILURE("can't resize below mapped offset")
+        );
+    if (!unmap_file())
+        cleanup_and_throw("failed unmapping file");
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    stream_offset offset = ::SetFilePointer(handle_, 0, NULL, FILE_CURRENT);
+    if (offset == INVALID_SET_FILE_POINTER && ::GetLastError() != NO_ERROR)
+         cleanup_and_throw("failed querying file pointer");
+    LONG sizehigh = (new_size >> (sizeof(LONG) * 8));
+    LONG sizelow = (new_size & 0xffffffff);
+    DWORD result = ::SetFilePointer(handle_, sizelow, &sizehigh, FILE_BEGIN);
+    if ((result == INVALID_SET_FILE_POINTER && ::GetLastError() != NO_ERROR)
+        || !::SetEndOfFile(handle_))
+        cleanup_and_throw("failed resizing mapped file");
+    sizehigh = (offset >> (sizeof(LONG) * 8));
+    sizelow = (offset & 0xffffffff);
+    ::SetFilePointer(handle_, sizelow, &sizehigh, FILE_BEGIN);
+#else
+    if (BOOST_IOSTREAMS_FD_TRUNCATE(handle_, new_size) == -1)
+        cleanup_and_throw("failed resizing mapped file");
+#endif
+    size_ = new_size;
+    param_type p(params_);
+    map_file(p);  // May modify p.hint
+    params_ = p;
+}
+
+int mapped_file_impl::alignment()
+{
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    SYSTEM_INFO info;
+    ::GetSystemInfo(&info);
+    return static_cast<int>(info.dwAllocationGranularity);
+#else
+    return static_cast<int>(sysconf(_SC_PAGESIZE));
+#endif
+}
+
+void mapped_file_impl::open_file(param_type p)
+{
+    bool readonly = p.flags != mapped_file::readwrite;
+#ifdef BOOST_IOSTREAMS_WINDOWS
+
+    // Open file
+    DWORD dwDesiredAccess =
+        readonly ?
+            GENERIC_READ :
+            (GENERIC_READ | GENERIC_WRITE);
+    DWORD dwCreationDisposition = (p.new_file_size != 0 && !readonly) ? 
+        CREATE_ALWAYS : 
+        OPEN_EXISTING;
+    DWORD dwFlagsandAttributes =
+        readonly ?
+            FILE_ATTRIBUTE_READONLY :
+            FILE_ATTRIBUTE_TEMPORARY;
+    handle_ = p.path.is_wide() ?
+        ::CreateFileW( 
+            p.path.c_wstr(),
+            dwDesiredAccess,
+            FILE_SHARE_READ,
+            NULL,
+            dwCreationDisposition,
+            dwFlagsandAttributes,
+            NULL ) :
+        ::CreateFileA( 
+            p.path.c_str(),
+            dwDesiredAccess,
+            FILE_SHARE_READ,
+            NULL,
+            dwCreationDisposition,
+            dwFlagsandAttributes,
+            NULL );
+    if (handle_ == INVALID_HANDLE_VALUE)
+        cleanup_and_throw("failed opening file");
+
+    // Set file size
+    if (p.new_file_size != 0 && !readonly) {
+        LONG sizehigh = (p.new_file_size >> (sizeof(LONG) * 8));
+        LONG sizelow = (p.new_file_size & 0xffffffff);
+        DWORD result = ::SetFilePointer(handle_, sizelow, &sizehigh, FILE_BEGIN);
+        if ((result == INVALID_SET_FILE_POINTER && ::GetLastError() != NO_ERROR)
+            || !::SetEndOfFile(handle_))
+            cleanup_and_throw("failed setting file size");
+    }
+
+    // Determine file size. Dynamically locate GetFileSizeEx for compatibility
+    // with old Platform SDK (thanks to Pavel Vozenilik).
+    typedef BOOL (WINAPI *func)(HANDLE, PLARGE_INTEGER);
+    HMODULE hmod = ::GetModuleHandleA("kernel32.dll");
+    func get_size =
+        reinterpret_cast<func>(::GetProcAddress(hmod, "GetFileSizeEx"));
+    if (get_size) {
+        LARGE_INTEGER info;
+        if (get_size(handle_, &info)) {
+            boost::intmax_t size =
+                ( (static_cast<boost::intmax_t>(info.HighPart) << 32) |
+                  info.LowPart );
+            size_ =
+                static_cast<std::size_t>(
+                    p.length != max_length ?
+                        std::min<boost::intmax_t>(p.length, size) :
+                        size
+                );
+        } else {
+            cleanup_and_throw("failed querying file size");
+            return;
+        }
+    } else {
+        DWORD hi;
+        DWORD low;
+        if ( (low = ::GetFileSize(handle_, &hi))
+                 !=
+             INVALID_FILE_SIZE )
+        {
+            boost::intmax_t size =
+                (static_cast<boost::intmax_t>(hi) << 32) | low;
+            size_ =
+                static_cast<std::size_t>(
+                    p.length != max_length ?
+                        std::min<boost::intmax_t>(p.length, size) :
+                        size
+                );
+        } else {
+            cleanup_and_throw("failed querying file size");
+            return;
+        }
+    }
+#else // #ifdef BOOST_IOSTREAMS_WINDOWS
+
+    // Open file
+    int flags = (readonly ? O_RDONLY : O_RDWR);
+    if (p.new_file_size != 0 && !readonly)
+        flags |= (O_CREAT | O_TRUNC);
+    #ifdef _LARGEFILE64_SOURCE
+        flags |= O_LARGEFILE;
+    #endif
+    errno = 0;
+    handle_ = ::open(p.path.c_str(), flags, S_IRWXU);
+    if (errno != 0)
+        cleanup_and_throw("failed opening file");
+
+    //--------------Set file size---------------------------------------------//
+
+    if (p.new_file_size != 0 && !readonly)
+        if (BOOST_IOSTREAMS_FD_TRUNCATE(handle_, p.new_file_size) == -1)
+            cleanup_and_throw("failed setting file size");
+
+    //--------------Determine file size---------------------------------------//
+
+    bool success = true;
+    if (p.length != max_length) {
+        size_ = p.length;
+    } else {
+        struct BOOST_IOSTREAMS_FD_STAT info;
+        success = ::BOOST_IOSTREAMS_FD_FSTAT(handle_, &info) != -1;
+        size_ = info.st_size;
+    }
+    if (!success)
+        cleanup_and_throw("failed querying file size");
+#endif // #ifdef BOOST_IOSTREAMS_WINDOWS
+}
+
+void mapped_file_impl::try_map_file(param_type p)
+{
+    bool priv = p.flags == mapped_file::priv;
+    bool readonly = p.flags == mapped_file::readonly;
+#ifdef BOOST_IOSTREAMS_WINDOWS
+
+    // Create mapping
+    DWORD protect = priv ? 
+        PAGE_WRITECOPY : 
+        readonly ? 
+            PAGE_READONLY : 
+            PAGE_READWRITE;
+    mapped_handle_ = 
+        ::CreateFileMappingA( 
+            handle_, 
+            NULL,
+            protect,
+            0, 
+            0, 
+            NULL );
+    if (mapped_handle_ == NULL)
+        cleanup_and_throw("failed create mapping");
+
+    // Access data
+    DWORD access = priv ? 
+        FILE_MAP_COPY : 
+        readonly ? 
+            FILE_MAP_READ : 
+            FILE_MAP_WRITE;
+    void* data =
+        ::MapViewOfFileEx( 
+            mapped_handle_,
+            access,
+            (DWORD) (p.offset >> 32),
+            (DWORD) (p.offset & 0xffffffff),
+            (SIZE_T) (size_ != max_length ? size_ : 0), 
+            (LPVOID) p.hint );
+    if (!data)
+        cleanup_and_throw("failed mapping view");
+#else
+    void* data = 
+        ::BOOST_IOSTREAMS_FD_MMAP( 
+            const_cast<char*>(p.hint), 
+            size_,
+            readonly ? PROT_READ : (PROT_READ | PROT_WRITE),
+            priv ? MAP_PRIVATE : MAP_SHARED,
+            handle_, 
+            p.offset );
+    if (data == MAP_FAILED)
+        cleanup_and_throw("failed mapping file");
+#endif
+    data_ = static_cast<char*>(data);
+}
+
+void mapped_file_impl::map_file(param_type& p)
+{
+    try {
+        try_map_file(p);
+    } catch (const std::exception&) {
+        if (p.hint) {
+            p.hint = 0;
+            try_map_file(p);
+        } else {
+            throw;
+        }
+    }
+}
+
+bool mapped_file_impl::unmap_file()
+{
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    bool error = false;
+    error = !::UnmapViewOfFile(data_) || error;
+    error = !::CloseHandle(mapped_handle_) || error;
+    mapped_handle_ = NULL;
+    return !error;
+#else
+    return ::munmap(data_, size_) == 0;
+#endif
+}
+
+void mapped_file_impl::clear(bool error)
+{
+    params_ = param_type();
+    data_ = 0;
+    size_ = 0;
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    handle_ = INVALID_HANDLE_VALUE;
+    mapped_handle_ = NULL;
+#else
+    handle_ = 0;
+#endif
+    error_ = error;
+}
+
+// Called when an error is encountered during the execution of open_file or
+// map_file
+void mapped_file_impl::cleanup_and_throw(const char* msg)
+{
+#ifdef BOOST_IOSTREAMS_WINDOWS
+    DWORD error = GetLastError();
+    if (mapped_handle_ != NULL)
+        ::CloseHandle(mapped_handle_);
+    if (handle_ != INVALID_HANDLE_VALUE)
+        ::CloseHandle(handle_);
+    SetLastError(error);
+#else
+    int error = errno;
+    if (handle_ != 0)
+        ::close(handle_);
+    errno = error;
+#endif
+    clear(true);
+    boost::iostreams::detail::throw_system_failure(msg);
+}
+
+//------------------Implementation of mapped_file_params_base-----------------//
+
+void mapped_file_params_base::normalize()
+{
+    if (mode && flags)
+        boost::throw_exception(BOOST_IOSTREAMS_FAILURE(
+            "at most one of 'mode' and 'flags' may be specified"
+        ));
+    if (flags) {
+        switch (flags) {
+        case mapped_file::readonly:
+        case mapped_file::readwrite:
+        case mapped_file::priv:
+            break;
+        default:
+            boost::throw_exception(BOOST_IOSTREAMS_FAILURE("invalid flags"));
+        }
+    } else {
+        flags = (mode & BOOST_IOS::out) ? 
+            mapped_file::readwrite :
+            mapped_file::readonly;
+        mode = BOOST_IOS::openmode();
+    }
+    if (offset < 0)
+        boost::throw_exception(BOOST_IOSTREAMS_FAILURE("invalid offset"));
+    if (new_file_size < 0)
+        boost::throw_exception(
+            BOOST_IOSTREAMS_FAILURE("invalid new file size")
+        );
+}
+
+} // End namespace detail.
+
+//------------------Implementation of mapped_file_source----------------------//
+
+mapped_file_source::mapped_file_source() 
+    : pimpl_(new impl_type)
+    { }
+
+mapped_file_source::mapped_file_source(const mapped_file_source& other)
+    : pimpl_(other.pimpl_)
+    { }
+
+bool mapped_file_source::is_open() const
+{ return pimpl_->is_open(); }
+
+void mapped_file_source::close() { pimpl_->close(); }
+
+// safe_bool is explicitly qualified below to please msvc 7.1
+mapped_file_source::operator mapped_file_source::safe_bool() const
+{ return pimpl_->error() ? &safe_bool_helper::x : 0; }
+
+bool mapped_file_source::operator!() const
+{ return pimpl_->error(); }
+
+mapped_file_source::mapmode mapped_file_source::flags() const 
+{ return pimpl_->flags(); }
+
+mapped_file_source::size_type mapped_file_source::size() const
+{ return pimpl_->size(); }
+
+const char* mapped_file_source::data() const { return pimpl_->data(); }
+
+const char* mapped_file_source::begin() const { return data(); }
+
+const char* mapped_file_source::end() const { return data() + size(); }
+int mapped_file_source::alignment()
+{ return detail::mapped_file_impl::alignment(); }
+
+void mapped_file_source::init() { pimpl_.reset(new impl_type); }
+
+void mapped_file_source::open_impl(const param_type& p)
+{ pimpl_->open(p); }
+
+//------------------Implementation of mapped_file-----------------------------//
+
+mapped_file::mapped_file(const mapped_file& other)
+    : delegate_(other.delegate_)
+    { }
+
+void mapped_file::resize(stream_offset new_size)
+{ delegate_.pimpl_->resize(new_size); }
+
+//------------------Implementation of mapped_file_sink------------------------//
+
+mapped_file_sink::mapped_file_sink(const mapped_file_sink& other)
+    : mapped_file(static_cast<const mapped_file&>(other))
+    { }
+
+//----------------------------------------------------------------------------//
+
+} } // End namespaces iostreams, boost.
diff --git a/contrib/restricted/boost/iostreams/src/zlib.cpp b/contrib/restricted/boost/iostreams/src/zlib.cpp
new file mode 100644
index 0000000000..3dd7b1a89c
--- /dev/null
+++ b/contrib/restricted/boost/iostreams/src/zlib.cpp
@@ -0,0 +1,187 @@
+// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
+// (C) Copyright 2003-2007 Jonathan Turkanis
+// 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/iostreams for documentation.
+
+// To configure Boost to work with zlib, see the 
+// installation instructions here:
+// http://boost.org/libs/iostreams/doc/index.html?path=7
+
+// Define BOOST_IOSTREAMS_SOURCE so that <boost/iostreams/detail/config.hpp> 
+// knows that we are building the library (possibly exporting code), rather 
+// than using it (possibly importing code).
+#define BOOST_IOSTREAMS_SOURCE 
+
+#include <boost/throw_exception.hpp>
+#include <boost/iostreams/detail/config/dyn_link.hpp>
+#include <boost/iostreams/filter/zlib.hpp> 
+#include "zlib.h"   // Jean-loup Gailly's and Mark Adler's "zlib.h" header.
+                    // To configure Boost to work with zlib, see the 
+                    // installation instructions here:
+                    // http://boost.org/libs/iostreams/doc/index.html?path=7
+
+namespace boost { namespace iostreams {
+
+namespace zlib {
+
+                    // Compression levels
+
+const int no_compression       = Z_NO_COMPRESSION;
+const int best_speed           = Z_BEST_SPEED;
+const int best_compression     = Z_BEST_COMPRESSION;
+const int default_compression  = Z_DEFAULT_COMPRESSION;
+
+                    // Compression methods
+
+const int deflated             = Z_DEFLATED;
+
+                    // Compression strategies
+
+const int default_strategy     = Z_DEFAULT_STRATEGY;
+const int filtered             = Z_FILTERED;
+const int huffman_only         = Z_HUFFMAN_ONLY;
+
+                    // Status codes
+
+const int okay                 = Z_OK;
+const int stream_end           = Z_STREAM_END;
+const int stream_error         = Z_STREAM_ERROR;
+const int version_error        = Z_VERSION_ERROR;
+const int data_error           = Z_DATA_ERROR;
+const int mem_error            = Z_MEM_ERROR;
+const int buf_error            = Z_BUF_ERROR;
+
+                    // Flush codes
+
+const int finish               = Z_FINISH;
+const int no_flush             = Z_NO_FLUSH;
+const int sync_flush           = Z_SYNC_FLUSH;
+
+                    // Code for current OS
+
+//const int os_code              = OS_CODE;
+
+} // End namespace zlib. 
+
+//------------------Implementation of zlib_error------------------------------//
+                    
+zlib_error::zlib_error(int error) 
+    : BOOST_IOSTREAMS_FAILURE("zlib error"), error_(error) 
+    { }
+
+void zlib_error::check BOOST_PREVENT_MACRO_SUBSTITUTION(int error)
+{
+    switch (error) {
+    case Z_OK: 
+    case Z_STREAM_END: 
+    //case Z_BUF_ERROR: 
+        return;
+    case Z_MEM_ERROR: 
+        boost::throw_exception(std::bad_alloc());
+    default:
+        boost::throw_exception(zlib_error(error));
+        ;
+    }
+}
+
+//------------------Implementation of zlib_base-------------------------------//
+
+namespace detail {
+
+zlib_base::zlib_base()
+    : stream_(new z_stream), calculate_crc_(false), crc_(0), crc_imp_(0)
+    { }
+
+zlib_base::~zlib_base() { delete static_cast<z_stream*>(stream_); }
+
+void zlib_base::before( const char*& src_begin, const char* src_end,
+                        char*& dest_begin, char* dest_end )
+{
+    z_stream* s = static_cast<z_stream*>(stream_);
+    s->next_in = reinterpret_cast<zlib::byte*>(const_cast<char*>(src_begin));
+    s->avail_in = static_cast<zlib::uint>(src_end - src_begin);
+    s->next_out = reinterpret_cast<zlib::byte*>(dest_begin);
+    s->avail_out= static_cast<zlib::uint>(dest_end - dest_begin);
+}
+
+void zlib_base::after(const char*& src_begin, char*& dest_begin, bool compress)
+{
+    z_stream* s = static_cast<z_stream*>(stream_);
+    const char* next_in = reinterpret_cast<const char*>(s->next_in);
+    char* next_out = reinterpret_cast<char*>(s->next_out);
+    if (calculate_crc_) {
+        const zlib::byte* buf = compress ?
+            reinterpret_cast<const zlib::byte*>(src_begin) :
+            reinterpret_cast<const zlib::byte*>(
+                const_cast<const char*>(dest_begin)
+            );
+        zlib::uint length = compress ?
+            static_cast<zlib::uint>(next_in - src_begin) :
+            static_cast<zlib::uint>(next_out - dest_begin);
+        crc_ = crc_imp_ = crc32(crc_imp_, buf, length);
+    }
+    total_in_ = s->total_in;
+    total_out_ = s->total_out;
+    src_begin = next_in;
+    dest_begin = next_out;
+}
+
+int zlib_base::xdeflate(int flush)
+{ 
+    return ::deflate(static_cast<z_stream*>(stream_), flush);
+}
+
+int zlib_base::xinflate(int flush)
+{ 
+    return ::inflate(static_cast<z_stream*>(stream_), flush);
+}
+
+void zlib_base::reset(bool compress, bool realloc)
+{
+    z_stream* s = static_cast<z_stream*>(stream_);
+    // Undiagnosed bug:
+    // deflateReset(), etc., return Z_DATA_ERROR
+    //zlib_error::check BOOST_PREVENT_MACRO_SUBSTITUTION(
+        realloc ?
+            (compress ? deflateReset(s) : inflateReset(s)) :
+            (compress ? deflateEnd(s) : inflateEnd(s))
+                ;
+    //);
+    crc_imp_ = 0;
+}
+
+void zlib_base::do_init
+    ( const zlib_params& p, bool compress, 
+      zlib::xalloc_func /* alloc */, zlib::xfree_func /* free*/, 
+      void* derived )
+{
+    calculate_crc_ = p.calculate_crc;
+    z_stream* s = static_cast<z_stream*>(stream_);
+
+    // Current interface for customizing memory management 
+    // is non-conforming and has been disabled:
+    //    s->zalloc = alloc;
+    //    s->zfree = free;
+        s->zalloc = 0;
+        s->zfree = 0;
+    s->opaque = derived;
+    int window_bits = p.noheader? -p.window_bits : p.window_bits;
+    zlib_error::check BOOST_PREVENT_MACRO_SUBSTITUTION(
+        compress ?
+            deflateInit2( s, 
+                          p.level,
+                          p.method,
+                          window_bits,
+                          p.mem_level,
+                          p.strategy ) :
+            inflateInit2(s, window_bits)
+    );
+}
+
+} // End namespace detail.
+
+//----------------------------------------------------------------------------//
+
+} } // End namespaces iostreams, boost.