14 files changed, 1499 insertions, 345 deletions
diff --git a/3rdParty/Boost/src/boost/asio/impl/buffered_read_stream.hpp b/3rdParty/Boost/src/boost/asio/impl/buffered_read_stream.hpp
new file mode 100644
index 0000000..00bc204
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/impl/buffered_read_stream.hpp
@@ -0,0 +1,360 @@
+//
+// impl/buffered_read_stream.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// 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_ASIO_IMPL_BUFFERED_READ_STREAM_HPP
+#define BOOST_ASIO_IMPL_BUFFERED_READ_STREAM_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_cont_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename Stream>
+std::size_t buffered_read_stream<Stream>::fill()
+{
+  detail::buffer_resize_guard<detail::buffered_stream_storage>
+    resize_guard(storage_);
+  std::size_t previous_size = storage_.size();
+  storage_.resize(storage_.capacity());
+  storage_.resize(previous_size + next_layer_.read_some(buffer(
+          storage_.data() + previous_size,
+          storage_.size() - previous_size)));
+  resize_guard.commit();
+  return storage_.size() - previous_size;
+}
+
+template <typename Stream>
+std::size_t buffered_read_stream<Stream>::fill(boost::system::error_code& ec)
+{
+  detail::buffer_resize_guard<detail::buffered_stream_storage>
+    resize_guard(storage_);
+  std::size_t previous_size = storage_.size();
+  storage_.resize(storage_.capacity());
+  storage_.resize(previous_size + next_layer_.read_some(buffer(
+          storage_.data() + previous_size,
+          storage_.size() - previous_size),
+        ec));
+  resize_guard.commit();
+  return storage_.size() - previous_size;
+}
+
+namespace detail
+{
+  template <typename ReadHandler>
+  class buffered_fill_handler
+  {
+  public:
+    buffered_fill_handler(detail::buffered_stream_storage& storage,
+        std::size_t previous_size, ReadHandler& handler)
+      : storage_(storage),
+        previous_size_(previous_size),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    buffered_fill_handler(const buffered_fill_handler& other)
+      : storage_(other.storage_),
+        previous_size_(other.previous_size_),
+        handler_(other.handler_)
+    {
+    }
+
+    buffered_fill_handler(buffered_fill_handler&& other)
+      : storage_(other.storage_),
+        previous_size_(other.previous_size_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        const std::size_t bytes_transferred)
+    {
+      storage_.resize(previous_size_ + bytes_transferred);
+      handler_(ec, bytes_transferred);
+    }
+
+  //private:
+    detail::buffered_stream_storage& storage_;
+    std::size_t previous_size_;
+    ReadHandler handler_;
+  };
+
+  template <typename ReadHandler>
+  inline void* asio_handler_allocate(std::size_t size,
+      buffered_fill_handler<ReadHandler>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, this_handler->handler_);
+  }
+
+  template <typename ReadHandler>
+  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+      buffered_fill_handler<ReadHandler>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, this_handler->handler_);
+  }
+
+  template <typename ReadHandler>
+  inline bool asio_handler_is_continuation(
+      buffered_fill_handler<ReadHandler>* this_handler)
+  {
+    return boost_asio_handler_cont_helpers::is_continuation(
+          this_handler->handler_);
+  }
+
+  template <typename Function, typename ReadHandler>
+  inline void asio_handler_invoke(Function& function,
+      buffered_fill_handler<ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename ReadHandler>
+  inline void asio_handler_invoke(const Function& function,
+      buffered_fill_handler<ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+} // namespace detail
+
+template <typename Stream>
+template <typename ReadHandler>
+BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+buffered_read_stream<Stream>::async_fill(
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::async_result_init<
+    ReadHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+  std::size_t previous_size = storage_.size();
+  storage_.resize(storage_.capacity());
+  next_layer_.async_read_some(
+      buffer(
+        storage_.data() + previous_size,
+        storage_.size() - previous_size),
+      detail::buffered_fill_handler<BOOST_ASIO_HANDLER_TYPE(
+        ReadHandler, void (boost::system::error_code, std::size_t))>(
+        storage_, previous_size, init.handler));
+
+  return init.result.get();
+}
+
+template <typename Stream>
+template <typename MutableBufferSequence>
+std::size_t buffered_read_stream<Stream>::read_some(
+    const MutableBufferSequence& buffers)
+{
+  if (boost::asio::buffer_size(buffers) == 0)
+    return 0;
+
+  if (storage_.empty())
+    this->fill();
+
+  return this->copy(buffers);
+}
+
+template <typename Stream>
+template <typename MutableBufferSequence>
+std::size_t buffered_read_stream<Stream>::read_some(
+    const MutableBufferSequence& buffers, boost::system::error_code& ec)
+{
+  ec = boost::system::error_code();
+
+  if (boost::asio::buffer_size(buffers) == 0)
+    return 0;
+
+  if (storage_.empty() && !this->fill(ec))
+    return 0;
+
+  return this->copy(buffers);
+}
+
+namespace detail
+{
+  template <typename MutableBufferSequence, typename ReadHandler>
+  class buffered_read_some_handler
+  {
+  public:
+    buffered_read_some_handler(detail::buffered_stream_storage& storage,
+        const MutableBufferSequence& buffers, ReadHandler& handler)
+      : storage_(storage),
+        buffers_(buffers),
+        handler_(handler)
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+      buffered_read_some_handler(const buffered_read_some_handler& other)
+        : storage_(other.storage_),
+          buffers_(other.buffers_),
+          handler_(other.handler_)
+      {
+      }
+
+      buffered_read_some_handler(buffered_read_some_handler&& other)
+        : storage_(other.storage_),
+          buffers_(other.buffers_),
+          handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+      {
+      }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec, std::size_t)
+    {
+      if (ec || storage_.empty())
+      {
+        const std::size_t length = 0;
+        handler_(ec, length);
+      }
+      else
+      {
+        const std::size_t bytes_copied = boost::asio::buffer_copy(
+            buffers_, storage_.data(), storage_.size());
+        storage_.consume(bytes_copied);
+        handler_(ec, bytes_copied);
+      }
+    }
+
+  //private:
+    detail::buffered_stream_storage& storage_;
+    MutableBufferSequence buffers_;
+    ReadHandler handler_;
+  };
+
+  template <typename MutableBufferSequence, typename ReadHandler>
+  inline void* asio_handler_allocate(std::size_t size,
+      buffered_read_some_handler<
+        MutableBufferSequence, ReadHandler>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, this_handler->handler_);
+  }
+
+  template <typename MutableBufferSequence, typename ReadHandler>
+  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+      buffered_read_some_handler<
+        MutableBufferSequence, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, this_handler->handler_);
+  }
+
+  template <typename MutableBufferSequence, typename ReadHandler>
+  inline bool asio_handler_is_continuation(
+      buffered_read_some_handler<
+        MutableBufferSequence, ReadHandler>* this_handler)
+  {
+    return boost_asio_handler_cont_helpers::is_continuation(
+          this_handler->handler_);
+  }
+
+  template <typename Function, typename MutableBufferSequence,
+      typename ReadHandler>
+  inline void asio_handler_invoke(Function& function,
+      buffered_read_some_handler<
+        MutableBufferSequence, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename MutableBufferSequence,
+      typename ReadHandler>
+  inline void asio_handler_invoke(const Function& function,
+      buffered_read_some_handler<
+        MutableBufferSequence, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+} // namespace detail
+
+template <typename Stream>
+template <typename MutableBufferSequence, typename ReadHandler>
+BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+buffered_read_stream<Stream>::async_read_some(
+    const MutableBufferSequence& buffers,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::async_result_init<
+    ReadHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+  if (boost::asio::buffer_size(buffers) == 0 || !storage_.empty())
+  {
+    next_layer_.async_read_some(boost::asio::mutable_buffers_1(0, 0),
+        detail::buffered_read_some_handler<
+          MutableBufferSequence, BOOST_ASIO_HANDLER_TYPE(
+            ReadHandler, void (boost::system::error_code, std::size_t))>(
+            storage_, buffers, init.handler));
+  }
+  else
+  {
+    this->async_fill(detail::buffered_read_some_handler<
+          MutableBufferSequence, BOOST_ASIO_HANDLER_TYPE(
+            ReadHandler, void (boost::system::error_code, std::size_t))>(
+            storage_, buffers, init.handler));
+  }
+
+  return init.result.get();
+}
+
+template <typename Stream>
+template <typename MutableBufferSequence>
+std::size_t buffered_read_stream<Stream>::peek(
+    const MutableBufferSequence& buffers)
+{
+  if (storage_.empty())
+    this->fill();
+  return this->peek_copy(buffers);
+}
+
+template <typename Stream>
+template <typename MutableBufferSequence>
+std::size_t buffered_read_stream<Stream>::peek(
+    const MutableBufferSequence& buffers, boost::system::error_code& ec)
+{
+  ec = boost::system::error_code();
+  if (storage_.empty() && !this->fill(ec))
+    return 0;
+  return this->peek_copy(buffers);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_BUFFERED_READ_STREAM_HPP
diff --git a/3rdParty/Boost/src/boost/asio/impl/buffered_write_stream.hpp b/3rdParty/Boost/src/boost/asio/impl/buffered_write_stream.hpp
new file mode 100644
index 0000000..6501208
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/impl/buffered_write_stream.hpp
@@ -0,0 +1,340 @@
+//
+// impl/buffered_write_stream.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// 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_ASIO_IMPL_BUFFERED_WRITE_STREAM_HPP
+#define BOOST_ASIO_IMPL_BUFFERED_WRITE_STREAM_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_cont_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename Stream>
+std::size_t buffered_write_stream<Stream>::flush()
+{
+  std::size_t bytes_written = write(next_layer_,
+      buffer(storage_.data(), storage_.size()));
+  storage_.consume(bytes_written);
+  return bytes_written;
+}
+
+template <typename Stream>
+std::size_t buffered_write_stream<Stream>::flush(boost::system::error_code& ec)
+{
+  std::size_t bytes_written = write(next_layer_,
+      buffer(storage_.data(), storage_.size()),
+      transfer_all(), ec);
+  storage_.consume(bytes_written);
+  return bytes_written;
+}
+
+namespace detail
+{
+  template <typename WriteHandler>
+  class buffered_flush_handler
+  {
+  public:
+    buffered_flush_handler(detail::buffered_stream_storage& storage,
+        WriteHandler& handler)
+      : storage_(storage),
+        handler_(handler)
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    buffered_flush_handler(const buffered_flush_handler& other)
+      : storage_(other.storage_),
+        handler_(other.handler_)
+    {
+    }
+
+    buffered_flush_handler(buffered_flush_handler&& other)
+      : storage_(other.storage_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        const std::size_t bytes_written)
+    {
+      storage_.consume(bytes_written);
+      handler_(ec, bytes_written);
+    }
+
+  //private:
+    detail::buffered_stream_storage& storage_;
+    WriteHandler handler_;
+  };
+
+  template <typename WriteHandler>
+  inline void* asio_handler_allocate(std::size_t size,
+      buffered_flush_handler<WriteHandler>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, this_handler->handler_);
+  }
+
+  template <typename WriteHandler>
+  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+      buffered_flush_handler<WriteHandler>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, this_handler->handler_);
+  }
+
+  template <typename WriteHandler>
+  inline bool asio_handler_is_continuation(
+      buffered_flush_handler<WriteHandler>* this_handler)
+  {
+    return boost_asio_handler_cont_helpers::is_continuation(
+          this_handler->handler_);
+  }
+
+  template <typename Function, typename WriteHandler>
+  inline void asio_handler_invoke(Function& function,
+      buffered_flush_handler<WriteHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename WriteHandler>
+  inline void asio_handler_invoke(const Function& function,
+      buffered_flush_handler<WriteHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+}
+
+template <typename Stream>
+template <typename WriteHandler>
+BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (boost::system::error_code, std::size_t))
+buffered_write_stream<Stream>::async_flush(
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a WriteHandler.
+  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+  detail::async_result_init<
+    WriteHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
+  async_write(next_layer_, buffer(storage_.data(), storage_.size()),
+      detail::buffered_flush_handler<BOOST_ASIO_HANDLER_TYPE(
+        WriteHandler, void (boost::system::error_code, std::size_t))>(
+        storage_, init.handler));
+
+  return init.result.get();
+}
+
+template <typename Stream>
+template <typename ConstBufferSequence>
+std::size_t buffered_write_stream<Stream>::write_some(
+    const ConstBufferSequence& buffers)
+{
+  if (boost::asio::buffer_size(buffers) == 0)
+    return 0;
+
+  if (storage_.size() == storage_.capacity())
+    this->flush();
+
+  return this->copy(buffers);
+}
+
+template <typename Stream>
+template <typename ConstBufferSequence>
+std::size_t buffered_write_stream<Stream>::write_some(
+    const ConstBufferSequence& buffers, boost::system::error_code& ec)
+{
+  ec = boost::system::error_code();
+
+  if (boost::asio::buffer_size(buffers) == 0)
+    return 0;
+
+  if (storage_.size() == storage_.capacity() && !flush(ec))
+    return 0;
+
+  return this->copy(buffers);
+}
+
+namespace detail
+{
+  template <typename ConstBufferSequence, typename WriteHandler>
+  class buffered_write_some_handler
+  {
+  public:
+    buffered_write_some_handler(detail::buffered_stream_storage& storage,
+        const ConstBufferSequence& buffers, WriteHandler& handler)
+      : storage_(storage),
+        buffers_(buffers),
+        handler_(handler)
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+      buffered_write_some_handler(const buffered_write_some_handler& other)
+        : storage_(other.storage_),
+          buffers_(other.buffers_),
+          handler_(other.handler_)
+      {
+      }
+
+      buffered_write_some_handler(buffered_write_some_handler&& other)
+        : storage_(other.storage_),
+          buffers_(other.buffers_),
+          handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+      {
+      }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec, std::size_t)
+    {
+      if (ec)
+      {
+        const std::size_t length = 0;
+        handler_(ec, length);
+      }
+      else
+      {
+        std::size_t orig_size = storage_.size();
+        std::size_t space_avail = storage_.capacity() - orig_size;
+        std::size_t bytes_avail = boost::asio::buffer_size(buffers_);
+        std::size_t length = bytes_avail < space_avail
+          ? bytes_avail : space_avail;
+        storage_.resize(orig_size + length);
+        const std::size_t bytes_copied = boost::asio::buffer_copy(
+            storage_.data() + orig_size, buffers_, length);
+        handler_(ec, bytes_copied);
+      }
+    }
+
+  //private:
+    detail::buffered_stream_storage& storage_;
+    ConstBufferSequence buffers_;
+    WriteHandler handler_;
+  };
+
+  template <typename ConstBufferSequence, typename WriteHandler>
+  inline void* asio_handler_allocate(std::size_t size,
+      buffered_write_some_handler<
+        ConstBufferSequence, WriteHandler>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, this_handler->handler_);
+  }
+
+  template <typename ConstBufferSequence, typename WriteHandler>
+  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+      buffered_write_some_handler<
+        ConstBufferSequence, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, this_handler->handler_);
+  }
+
+  template <typename ConstBufferSequence, typename WriteHandler>
+  inline bool asio_handler_is_continuation(
+      buffered_write_some_handler<
+        ConstBufferSequence, WriteHandler>* this_handler)
+  {
+    return boost_asio_handler_cont_helpers::is_continuation(
+          this_handler->handler_);
+  }
+
+  template <typename Function, typename ConstBufferSequence,
+      typename WriteHandler>
+  inline void asio_handler_invoke(Function& function,
+      buffered_write_some_handler<
+        ConstBufferSequence, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename ConstBufferSequence,
+      typename WriteHandler>
+  inline void asio_handler_invoke(const Function& function,
+      buffered_write_some_handler<
+        ConstBufferSequence, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+} // namespace detail
+
+template <typename Stream>
+template <typename ConstBufferSequence, typename WriteHandler>
+BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (boost::system::error_code, std::size_t))
+buffered_write_stream<Stream>::async_write_some(
+    const ConstBufferSequence& buffers,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a WriteHandler.
+  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+  detail::async_result_init<
+    WriteHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
+  if (boost::asio::buffer_size(buffers) == 0
+      || storage_.size() < storage_.capacity())
+  {
+    next_layer_.async_write_some(boost::asio::const_buffers_1(0, 0),
+        detail::buffered_write_some_handler<
+          ConstBufferSequence, BOOST_ASIO_HANDLER_TYPE(
+            WriteHandler, void (boost::system::error_code, std::size_t))>(
+            storage_, buffers, init.handler));
+  }
+  else
+  {
+    this->async_flush(detail::buffered_write_some_handler<
+          ConstBufferSequence, BOOST_ASIO_HANDLER_TYPE(
+            WriteHandler, void (boost::system::error_code, std::size_t))>(
+            storage_, buffers, init.handler));
+  }
+
+  return init.result.get();
+}
+
+template <typename Stream>
+template <typename ConstBufferSequence>
+std::size_t buffered_write_stream<Stream>::copy(
+    const ConstBufferSequence& buffers)
+{
+  std::size_t orig_size = storage_.size();
+  std::size_t space_avail = storage_.capacity() - orig_size;
+  std::size_t bytes_avail = boost::asio::buffer_size(buffers);
+  std::size_t length = bytes_avail < space_avail ? bytes_avail : space_avail;
+  storage_.resize(orig_size + length);
+  return boost::asio::buffer_copy(
+      storage_.data() + orig_size, buffers, length);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_BUFFERED_WRITE_STREAM_HPP
diff --git a/3rdParty/Boost/src/boost/asio/impl/connect.hpp b/3rdParty/Boost/src/boost/asio/impl/connect.hpp
index a21bb2d..68a903e 100644
--- a/3rdParty/Boost/src/boost/asio/impl/connect.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/connect.hpp
@@ -2,7 +2,7 @@
 // impl/connect.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // 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)
@@ -18,6 +18,7 @@
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/consuming_buffers.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_cont_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
@@ -184,6 +185,7 @@ namespace detail
         socket_(sock),
         iter_(begin),
         end_(end),
+        start_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler))
     {
     }
@@ -194,6 +196,7 @@ namespace detail
         socket_(other.socket_),
         iter_(other.iter_),
         end_(other.end_),
+        start_(other.start_),
         handler_(other.handler_)
     {
     }
@@ -203,6 +206,7 @@ namespace detail
         socket_(other.socket_),
         iter_(other.iter_),
         end_(other.end_),
+        start_(other.start_),
         handler_(BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(other.handler_))
     {
     }
@@ -210,7 +214,7 @@ namespace detail
 
     void operator()(boost::system::error_code ec, int start = 0)
     {
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         for (;;)
@@ -258,6 +262,7 @@ namespace detail
     basic_socket<Protocol, SocketService>& socket_;
     Iterator iter_;
     Iterator end_;
+    int start_;
     ComposedConnectHandler handler_;
   };
 
@@ -281,6 +286,16 @@ namespace detail
         pointer, size, this_handler->handler_);
   }
 
+  template <typename Protocol, typename SocketService, typename Iterator,
+      typename ConnectCondition, typename ComposedConnectHandler>
+  inline bool asio_handler_is_continuation(
+      connect_op<Protocol, SocketService, Iterator,
+        ConnectCondition, ComposedConnectHandler>* this_handler)
+  {
+    return boost_asio_handler_cont_helpers::is_continuation(
+        this_handler->handler_);
+  }
+
   template <typename Function, typename Protocol,
       typename SocketService, typename Iterator,
       typename ConnectCondition, typename ComposedConnectHandler>
@@ -302,25 +317,13 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
-
-  template <typename Protocol, typename SocketService, typename Iterator,
-      typename ConnectCondition, typename ComposedConnectHandler>
-  inline connect_op<Protocol, SocketService, Iterator,
-      ConnectCondition, ComposedConnectHandler>
-  make_connect_op(basic_socket<Protocol, SocketService>& sock,
-      const Iterator& begin, const Iterator& end,
-      const ConnectCondition& connect_condition,
-      ComposedConnectHandler handler)
-  {
-    return connect_op<Protocol, SocketService, Iterator,
-      ConnectCondition, ComposedConnectHandler>(
-        sock, begin, end, connect_condition, handler);
-  }
 } // namespace detail
 
 template <typename Protocol, typename SocketService,
     typename Iterator, typename ComposedConnectHandler>
-inline void async_connect(basic_socket<Protocol, SocketService>& s,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(ComposedConnectHandler,
+    void (boost::system::error_code, Iterator))
+async_connect(basic_socket<Protocol, SocketService>& s,
     Iterator begin, BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler)
 {
   // If you get an error on the following line it means that your handler does
@@ -328,15 +331,24 @@ inline void async_connect(basic_socket<Protocol, SocketService>& s,
   BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
       ComposedConnectHandler, handler, Iterator) type_check;
 
-  detail::make_connect_op(s, begin, Iterator(),
-    detail::default_connect_condition(),
-      BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler))(
-        boost::system::error_code(), 1);
+  detail::async_result_init<ComposedConnectHandler,
+    void (boost::system::error_code, Iterator)> init(
+      BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler));
+
+  detail::connect_op<Protocol, SocketService, Iterator,
+    detail::default_connect_condition, BOOST_ASIO_HANDLER_TYPE(
+      ComposedConnectHandler, void (boost::system::error_code, Iterator))>(s,
+        begin, Iterator(), detail::default_connect_condition(), init.handler)(
+          boost::system::error_code(), 1);
+
+  return init.result.get();
 }
 
 template <typename Protocol, typename SocketService,
     typename Iterator, typename ComposedConnectHandler>
-inline void async_connect(basic_socket<Protocol, SocketService>& s,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(ComposedConnectHandler,
+    void (boost::system::error_code, Iterator))
+async_connect(basic_socket<Protocol, SocketService>& s,
     Iterator begin, Iterator end,
     BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler)
 {
@@ -345,15 +357,24 @@ inline void async_connect(basic_socket<Protocol, SocketService>& s,
   BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
       ComposedConnectHandler, handler, Iterator) type_check;
 
-  detail::make_connect_op(s, begin, end,
-    detail::default_connect_condition(),
-      BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler))(
-        boost::system::error_code(), 1);
+  detail::async_result_init<ComposedConnectHandler,
+    void (boost::system::error_code, Iterator)> init(
+      BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler));
+
+  detail::connect_op<Protocol, SocketService, Iterator,
+    detail::default_connect_condition, BOOST_ASIO_HANDLER_TYPE(
+      ComposedConnectHandler, void (boost::system::error_code, Iterator))>(s,
+        begin, end, detail::default_connect_condition(), init.handler)(
+          boost::system::error_code(), 1);
+
+  return init.result.get();
 }
 
 template <typename Protocol, typename SocketService, typename Iterator,
     typename ConnectCondition, typename ComposedConnectHandler>
-inline void async_connect(basic_socket<Protocol, SocketService>& s,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(ComposedConnectHandler,
+    void (boost::system::error_code, Iterator))
+async_connect(basic_socket<Protocol, SocketService>& s,
     Iterator begin, ConnectCondition connect_condition,
     BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler)
 {
@@ -362,14 +383,24 @@ inline void async_connect(basic_socket<Protocol, SocketService>& s,
   BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
       ComposedConnectHandler, handler, Iterator) type_check;
 
-  detail::make_connect_op(s, begin, Iterator(), connect_condition,
-    BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler))(
-      boost::system::error_code(), 1);
+  detail::async_result_init<ComposedConnectHandler,
+    void (boost::system::error_code, Iterator)> init(
+      BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler));
+
+  detail::connect_op<Protocol, SocketService, Iterator,
+    ConnectCondition, BOOST_ASIO_HANDLER_TYPE(
+      ComposedConnectHandler, void (boost::system::error_code, Iterator))>(s,
+        begin, Iterator(), connect_condition, init.handler)(
+          boost::system::error_code(), 1);
+
+  return init.result.get();
 }
 
 template <typename Protocol, typename SocketService, typename Iterator,
     typename ConnectCondition, typename ComposedConnectHandler>
-void async_connect(basic_socket<Protocol, SocketService>& s,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(ComposedConnectHandler,
+    void (boost::system::error_code, Iterator))
+async_connect(basic_socket<Protocol, SocketService>& s,
     Iterator begin, Iterator end, ConnectCondition connect_condition,
     BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler)
 {
@@ -378,9 +409,17 @@ void async_connect(basic_socket<Protocol, SocketService>& s,
   BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
       ComposedConnectHandler, handler, Iterator) type_check;
 
-  detail::make_connect_op(s, begin, end, connect_condition,
-    BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler))(
-      boost::system::error_code(), 1);
+  detail::async_result_init<ComposedConnectHandler,
+    void (boost::system::error_code, Iterator)> init(
+      BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler));
+
+  detail::connect_op<Protocol, SocketService, Iterator,
+    ConnectCondition, BOOST_ASIO_HANDLER_TYPE(
+      ComposedConnectHandler, void (boost::system::error_code, Iterator))>(s,
+        begin, end, connect_condition, init.handler)(
+          boost::system::error_code(), 1);
+
+  return init.result.get();
 }
 
 } // namespace asio
diff --git a/3rdParty/Boost/src/boost/asio/impl/error.ipp b/3rdParty/Boost/src/boost/asio/impl/error.ipp
index cfb7a99..ae43418 100644
--- a/3rdParty/Boost/src/boost/asio/impl/error.ipp
+++ b/3rdParty/Boost/src/boost/asio/impl/error.ipp
@@ -2,7 +2,7 @@
 // impl/error.ipp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // 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)
@@ -16,6 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+#include <string>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -24,14 +25,14 @@ namespace boost {
 namespace asio {
 namespace error {
 
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 
 namespace detail {
 
 class netdb_category : public boost::system::error_category
 {
 public:
-  const char* name() const
+  const char* name() const BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT
   {
     return "asio.netdb";
   }
@@ -63,7 +64,7 @@ namespace detail {
 class addrinfo_category : public boost::system::error_category
 {
 public:
-  const char* name() const
+  const char* name() const BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT
   {
     return "asio.addrinfo";
   }
@@ -86,14 +87,14 @@ const boost::system::error_category& get_addrinfo_category()
   return instance;
 }
 
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 
 namespace detail {
 
 class misc_category : public boost::system::error_category
 {
 public:
-  const char* name() const
+  const char* name() const BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT
   {
     return "asio.misc";
   }
diff --git a/3rdParty/Boost/src/boost/asio/impl/handler_alloc_hook.ipp b/3rdParty/Boost/src/boost/asio/impl/handler_alloc_hook.ipp
new file mode 100644
index 0000000..2561f3b
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/impl/handler_alloc_hook.ipp
@@ -0,0 +1,79 @@
+//
+// impl/handler_alloc_hook.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// 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_ASIO_IMPL_HANDLER_ALLOC_HOOK_IPP
+#define BOOST_ASIO_IMPL_HANDLER_ALLOC_HOOK_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/call_stack.hpp>
+#include <boost/asio/handler_alloc_hook.hpp>
+
+#if !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+# if defined(BOOST_ASIO_HAS_IOCP)
+#  include <boost/asio/detail/win_iocp_thread_info.hpp>
+# else // defined(BOOST_ASIO_HAS_IOCP)
+#  include <boost/asio/detail/task_io_service_thread_info.hpp>
+# endif // defined(BOOST_ASIO_HAS_IOCP)
+#endif // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+namespace detail { class win_iocp_io_service; }
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+
+void* asio_handler_allocate(std::size_t size, ...)
+{
+#if !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+# if defined(BOOST_ASIO_HAS_IOCP)
+  typedef detail::win_iocp_io_service io_service_impl;
+  typedef detail::win_iocp_thread_info thread_info;
+# else // defined(BOOST_ASIO_HAS_IOCP)
+  typedef detail::task_io_service io_service_impl;
+  typedef detail::task_io_service_thread_info thread_info;
+# endif // defined(BOOST_ASIO_HAS_IOCP)
+  typedef detail::call_stack<io_service_impl, thread_info> call_stack;
+  return thread_info::allocate(call_stack::top(), size);
+#else // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+  return ::operator new(size);
+#endif // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+}
+
+void asio_handler_deallocate(void* pointer, std::size_t size, ...)
+{
+#if !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+# if defined(BOOST_ASIO_HAS_IOCP)
+  typedef detail::win_iocp_io_service io_service_impl;
+  typedef detail::win_iocp_thread_info thread_info;
+# else // defined(BOOST_ASIO_HAS_IOCP)
+  typedef detail::task_io_service io_service_impl;
+  typedef detail::task_io_service_thread_info thread_info;
+# endif // defined(BOOST_ASIO_HAS_IOCP)
+  typedef detail::call_stack<io_service_impl, thread_info> call_stack;
+  thread_info::deallocate(call_stack::top(), pointer, size);
+#else // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+  (void)size;
+  ::operator delete(pointer);
+#endif // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_HANDLER_ALLOC_HOOK_IPP
diff --git a/3rdParty/Boost/src/boost/asio/impl/io_service.hpp b/3rdParty/Boost/src/boost/asio/impl/io_service.hpp
index 510de0e..4c6f2e1 100644
--- a/3rdParty/Boost/src/boost/asio/impl/io_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/io_service.hpp
@@ -2,7 +2,7 @@
 // impl/io_service.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // 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)
@@ -77,24 +77,37 @@ namespace boost {
 namespace asio {
 
 template <typename CompletionHandler>
-inline void io_service::dispatch(
-    BOOST_ASIO_MOVE_ARG(CompletionHandler) handler)
+inline BOOST_ASIO_INITFN_RESULT_TYPE(CompletionHandler, void ())
+io_service::dispatch(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a CompletionHandler.
   BOOST_ASIO_COMPLETION_HANDLER_CHECK(CompletionHandler, handler) type_check;
 
-  impl_.dispatch(BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
+  detail::async_result_init<
+    CompletionHandler, void ()> init(
+      BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
+
+  impl_.dispatch(init.handler);
+
+  return init.result.get();
 }
 
 template <typename CompletionHandler>
-inline void io_service::post(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler)
+inline BOOST_ASIO_INITFN_RESULT_TYPE(CompletionHandler, void ())
+io_service::post(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a CompletionHandler.
   BOOST_ASIO_COMPLETION_HANDLER_CHECK(CompletionHandler, handler) type_check;
 
-  impl_.post(BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
+  detail::async_result_init<
+    CompletionHandler, void ()> init(
+      BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
+
+  impl_.post(init.handler);
+
+  return init.result.get();
 }
 
 template <typename Handler>
diff --git a/3rdParty/Boost/src/boost/asio/impl/io_service.ipp b/3rdParty/Boost/src/boost/asio/impl/io_service.ipp
index 1e3af48..0bb5bbf 100644
--- a/3rdParty/Boost/src/boost/asio/impl/io_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/impl/io_service.ipp
@@ -2,7 +2,7 @@
 // impl/io_service.ipp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // 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)
@@ -16,8 +16,8 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/limits.hpp>
 #include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/limits.hpp>
 #include <boost/asio/detail/scoped_ptr.hpp>
 #include <boost/asio/detail/service_registry.hpp>
 #include <boost/asio/detail/throw_error.hpp>
diff --git a/3rdParty/Boost/src/boost/asio/impl/read.hpp b/3rdParty/Boost/src/boost/asio/impl/read.hpp
index 9290cd4..86f8776 100644
--- a/3rdParty/Boost/src/boost/asio/impl/read.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/read.hpp
@@ -2,7 +2,7 @@
 // impl/read.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // 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)
@@ -24,6 +24,7 @@
 #include <boost/asio/detail/consuming_buffers.hpp>
 #include <boost/asio/detail/dependent_type.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_cont_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
@@ -83,7 +84,7 @@ inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
   return bytes_transferred;
 }
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 template <typename SyncReadStream, typename Allocator,
     typename CompletionCondition>
@@ -138,7 +139,7 @@ inline std::size_t read(SyncReadStream& s,
   return bytes_transferred;
 }
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 namespace detail
 {
@@ -154,6 +155,7 @@ namespace detail
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
@@ -164,6 +166,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -173,6 +176,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
     {
@@ -182,7 +186,7 @@ namespace detail
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         buffers_.prepare(this->check_for_completion(ec, total_transferred_));
@@ -207,6 +211,7 @@ namespace detail
     AsyncReadStream& stream_;
     boost::asio::detail::consuming_buffers<
       mutable_buffer, MutableBufferSequence> buffers_;
+    int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
@@ -225,6 +230,7 @@ namespace detail
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffer_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
@@ -235,6 +241,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffer_(other.buffer_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -244,6 +251,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffer_(other.buffer_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
     {
@@ -254,7 +262,7 @@ namespace detail
         std::size_t bytes_transferred, int start = 0)
     {
       std::size_t n = 0;
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
@@ -278,6 +286,7 @@ namespace detail
   //private:
     AsyncReadStream& stream_;
     boost::asio::mutable_buffer buffer_;
+    int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
@@ -295,6 +304,7 @@ namespace detail
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
@@ -305,6 +315,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -314,6 +325,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
     {
@@ -330,7 +342,7 @@ namespace detail
       std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
       std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
       std::size_t n = 0;
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
@@ -357,6 +369,7 @@ namespace detail
   //private:
     AsyncReadStream& stream_;
     boost::array<Elem, 2> buffers_;
+    int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
@@ -376,6 +389,7 @@ namespace detail
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
@@ -386,6 +400,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -395,6 +410,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
     {
@@ -411,7 +427,7 @@ namespace detail
       std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
       std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
       std::size_t n = 0;
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
@@ -438,6 +454,7 @@ namespace detail
   //private:
     AsyncReadStream& stream_;
     std::array<Elem, 2> buffers_;
+    int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
@@ -464,6 +481,17 @@ namespace detail
         pointer, size, this_handler->handler_);
   }
 
+  template <typename AsyncReadStream, typename MutableBufferSequence,
+      typename CompletionCondition, typename ReadHandler>
+  inline bool asio_handler_is_continuation(
+      read_op<AsyncReadStream, MutableBufferSequence,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    return this_handler->start_ == 0 ? true
+      : boost_asio_handler_cont_helpers::is_continuation(
+          this_handler->handler_);
+  }
+
   template <typename Function, typename AsyncReadStream,
       typename MutableBufferSequence, typename CompletionCondition,
       typename ReadHandler>
@@ -485,22 +513,13 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
-
-  template <typename AsyncReadStream, typename MutableBufferSequence,
-      typename CompletionCondition, typename ReadHandler>
-  inline read_op<AsyncReadStream, MutableBufferSequence,
-      CompletionCondition, ReadHandler>
-  make_read_op(AsyncReadStream& s, const MutableBufferSequence& buffers,
-      CompletionCondition completion_condition, ReadHandler handler)
-  {
-    return read_op<AsyncReadStream, MutableBufferSequence, CompletionCondition,
-      ReadHandler>(s, buffers, completion_condition, handler);
-  }
 } // namespace detail
 
 template <typename AsyncReadStream, typename MutableBufferSequence,
     typename CompletionCondition, typename ReadHandler>
-inline void async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition,
     BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
@@ -508,27 +527,44 @@ inline void async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
   // not meet the documented type requirements for a ReadHandler.
   BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::make_read_op(
-    s, buffers, completion_condition,
-      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
-        boost::system::error_code(), 0, 1);
+  detail::async_result_init<
+    ReadHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+  detail::read_op<AsyncReadStream, MutableBufferSequence,
+    CompletionCondition, BOOST_ASIO_HANDLER_TYPE(
+      ReadHandler, void (boost::system::error_code, std::size_t))>(
+        s, buffers, completion_condition, init.handler)(
+          boost::system::error_code(), 0, 1);
+
+  return init.result.get();
 }
 
 template <typename AsyncReadStream, typename MutableBufferSequence,
     typename ReadHandler>
-inline void async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
     BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a ReadHandler.
   BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::make_read_op(
-    s, buffers, transfer_all(), BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
-      boost::system::error_code(), 0, 1);
+  detail::async_result_init<
+    ReadHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+  detail::read_op<AsyncReadStream, MutableBufferSequence,
+    detail::transfer_all_t, BOOST_ASIO_HANDLER_TYPE(
+      ReadHandler, void (boost::system::error_code, std::size_t))>(
+        s, buffers, transfer_all(), init.handler)(
+          boost::system::error_code(), 0, 1);
+
+  return init.result.get();
 }
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 namespace detail
 {
@@ -545,6 +581,7 @@ namespace detail
           CompletionCondition>(completion_condition),
         stream_(stream),
         streambuf_(streambuf),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
@@ -555,6 +592,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         streambuf_(other.streambuf_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -564,6 +602,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         streambuf_(other.streambuf_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
     {
@@ -574,7 +613,7 @@ namespace detail
         std::size_t bytes_transferred, int start = 0)
     {
       std::size_t max_size, bytes_available;
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         max_size = this->check_for_completion(ec, total_transferred_);
@@ -599,6 +638,7 @@ namespace detail
   //private:
     AsyncReadStream& stream_;
     boost::asio::basic_streambuf<Allocator>& streambuf_;
+    int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
@@ -623,6 +663,17 @@ namespace detail
         pointer, size, this_handler->handler_);
   }
 
+  template <typename AsyncReadStream, typename Allocator,
+      typename CompletionCondition, typename ReadHandler>
+  inline bool asio_handler_is_continuation(
+      read_streambuf_op<AsyncReadStream, Allocator,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    return this_handler->start_ == 0 ? true
+      : boost_asio_handler_cont_helpers::is_continuation(
+          this_handler->handler_);
+  }
+
   template <typename Function, typename AsyncReadStream,
       typename Allocator, typename CompletionCondition, typename ReadHandler>
   inline void asio_handler_invoke(Function& function,
@@ -642,23 +693,13 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
-
-  template <typename AsyncReadStream, typename Allocator,
-      typename CompletionCondition, typename ReadHandler>
-  inline read_streambuf_op<AsyncReadStream, Allocator,
-      CompletionCondition, ReadHandler>
-  make_read_streambuf_op(
-      AsyncReadStream& s, boost::asio::basic_streambuf<Allocator>& b,
-      CompletionCondition completion_condition, ReadHandler handler)
-  {
-    return read_streambuf_op<AsyncReadStream, Allocator, CompletionCondition,
-      ReadHandler>(s, b, completion_condition, handler);
-  }
 } // namespace detail
 
 template <typename AsyncReadStream, typename Allocator,
     typename CompletionCondition, typename ReadHandler>
-inline void async_read(AsyncReadStream& s,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition,
     BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
@@ -667,13 +708,23 @@ inline void async_read(AsyncReadStream& s,
   // not meet the documented type requirements for a ReadHandler.
   BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::make_read_streambuf_op(
-    s, b, completion_condition, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
-      boost::system::error_code(), 0, 1);
+  detail::async_result_init<
+    ReadHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+  detail::read_streambuf_op<AsyncReadStream, Allocator,
+    CompletionCondition, BOOST_ASIO_HANDLER_TYPE(
+      ReadHandler, void (boost::system::error_code, std::size_t))>(
+        s, b, completion_condition, init.handler)(
+          boost::system::error_code(), 0, 1);
+
+  return init.result.get();
 }
 
 template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
-inline void async_read(AsyncReadStream& s,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
     BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
@@ -681,12 +732,20 @@ inline void async_read(AsyncReadStream& s,
   // not meet the documented type requirements for a ReadHandler.
   BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::make_read_streambuf_op(
-    s, b, transfer_all(), BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
-      boost::system::error_code(), 0, 1);
+  detail::async_result_init<
+    ReadHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+  detail::read_streambuf_op<AsyncReadStream, Allocator,
+    detail::transfer_all_t, BOOST_ASIO_HANDLER_TYPE(
+      ReadHandler, void (boost::system::error_code, std::size_t))>(
+        s, b, transfer_all(), init.handler)(
+          boost::system::error_code(), 0, 1);
+
+  return init.result.get();
 }
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/impl/read_at.hpp b/3rdParty/Boost/src/boost/asio/impl/read_at.hpp
index 08e37fe..877a7c7 100644
--- a/3rdParty/Boost/src/boost/asio/impl/read_at.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/read_at.hpp
@@ -2,7 +2,7 @@
 // impl/read_at.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // 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)
@@ -24,6 +24,7 @@
 #include <boost/asio/detail/consuming_buffers.hpp>
 #include <boost/asio/detail/dependent_type.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_cont_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
@@ -37,7 +38,7 @@ namespace asio {
 template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
     typename CompletionCondition>
 std::size_t read_at(SyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, const MutableBufferSequence& buffers,
+    uint64_t offset, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition, boost::system::error_code& ec)
 {
   ec = boost::system::error_code();
@@ -60,7 +61,7 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
 
 template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
 inline std::size_t read_at(SyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, const MutableBufferSequence& buffers)
+    uint64_t offset, const MutableBufferSequence& buffers)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = read_at(
@@ -71,7 +72,7 @@ inline std::size_t read_at(SyncRandomAccessReadDevice& d,
 
 template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
 inline std::size_t read_at(SyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, const MutableBufferSequence& buffers,
+    uint64_t offset, const MutableBufferSequence& buffers,
     boost::system::error_code& ec)
 {
   return read_at(d, offset, buffers, transfer_all(), ec);
@@ -80,7 +81,7 @@ inline std::size_t read_at(SyncRandomAccessReadDevice& d,
 template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
     typename CompletionCondition>
 inline std::size_t read_at(SyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, const MutableBufferSequence& buffers,
+    uint64_t offset, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition)
 {
   boost::system::error_code ec;
@@ -90,12 +91,12 @@ inline std::size_t read_at(SyncRandomAccessReadDevice& d,
   return bytes_transferred;
 }
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 template <typename SyncRandomAccessReadDevice, typename Allocator,
     typename CompletionCondition>
 std::size_t read_at(SyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition, boost::system::error_code& ec)
 {
   ec = boost::system::error_code();
@@ -118,7 +119,7 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
 
 template <typename SyncRandomAccessReadDevice, typename Allocator>
 inline std::size_t read_at(SyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b)
+    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = read_at(
@@ -129,7 +130,7 @@ inline std::size_t read_at(SyncRandomAccessReadDevice& d,
 
 template <typename SyncRandomAccessReadDevice, typename Allocator>
 inline std::size_t read_at(SyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
     boost::system::error_code& ec)
 {
   return read_at(d, offset, b, transfer_all(), ec);
@@ -138,7 +139,7 @@ inline std::size_t read_at(SyncRandomAccessReadDevice& d,
 template <typename SyncRandomAccessReadDevice, typename Allocator,
     typename CompletionCondition>
 inline std::size_t read_at(SyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition)
 {
   boost::system::error_code ec;
@@ -148,7 +149,7 @@ inline std::size_t read_at(SyncRandomAccessReadDevice& d,
   return bytes_transferred;
 }
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 namespace detail
 {
@@ -160,13 +161,14 @@ namespace detail
   {
   public:
     read_at_op(AsyncRandomAccessReadDevice& device,
-        boost::uint64_t offset, const MutableBufferSequence& buffers,
+        uint64_t offset, const MutableBufferSequence& buffers,
         CompletionCondition completion_condition, ReadHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffers_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
@@ -178,6 +180,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -188,6 +191,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
     {
@@ -197,7 +201,7 @@ namespace detail
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         buffers_.prepare(this->check_for_completion(ec, total_transferred_));
@@ -220,9 +224,10 @@ namespace detail
 
   //private:
     AsyncRandomAccessReadDevice& device_;
-    boost::uint64_t offset_;
+    uint64_t offset_;
     boost::asio::detail::consuming_buffers<
       mutable_buffer, MutableBufferSequence> buffers_;
+    int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
@@ -235,13 +240,14 @@ namespace detail
   {
   public:
     read_at_op(AsyncRandomAccessReadDevice& device,
-        boost::uint64_t offset, const boost::asio::mutable_buffers_1& buffers,
+        uint64_t offset, const boost::asio::mutable_buffers_1& buffers,
         CompletionCondition completion_condition, ReadHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffer_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
@@ -253,6 +259,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         buffer_(other.buffer_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -263,6 +270,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         buffer_(other.buffer_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
     {
@@ -273,7 +281,7 @@ namespace detail
         std::size_t bytes_transferred, int start = 0)
     {
       std::size_t n = 0;
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
@@ -296,8 +304,9 @@ namespace detail
 
   //private:
     AsyncRandomAccessReadDevice& device_;
-    boost::uint64_t offset_;
+    uint64_t offset_;
     boost::asio::mutable_buffer buffer_;
+    int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
@@ -310,13 +319,14 @@ namespace detail
   {
   public:
     read_at_op(AsyncRandomAccessReadDevice& device,
-        boost::uint64_t offset, const boost::array<Elem, 2>& buffers,
+        uint64_t offset, const boost::array<Elem, 2>& buffers,
         CompletionCondition completion_condition, ReadHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffers_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
@@ -328,6 +338,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -338,6 +349,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
     {
@@ -354,7 +366,7 @@ namespace detail
       std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
       std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
       std::size_t n = 0;
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
@@ -381,8 +393,9 @@ namespace detail
 
   //private:
     AsyncRandomAccessReadDevice& device_;
-    boost::uint64_t offset_;
+    uint64_t offset_;
     boost::array<Elem, 2> buffers_;
+    int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
@@ -397,13 +410,14 @@ namespace detail
   {
   public:
     read_at_op(AsyncRandomAccessReadDevice& device,
-        boost::uint64_t offset, const std::array<Elem, 2>& buffers,
+        uint64_t offset, const std::array<Elem, 2>& buffers,
         CompletionCondition completion_condition, ReadHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffers_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
@@ -415,6 +429,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -425,6 +440,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
     {
@@ -441,7 +457,7 @@ namespace detail
       std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
       std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
       std::size_t n = 0;
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
@@ -468,8 +484,9 @@ namespace detail
 
   //private:
     AsyncRandomAccessReadDevice& device_;
-    boost::uint64_t offset_;
+    uint64_t offset_;
     std::array<Elem, 2> buffers_;
+    int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
@@ -498,6 +515,18 @@ namespace detail
         pointer, size, this_handler->handler_);
   }
 
+  template <typename AsyncRandomAccessReadDevice,
+      typename MutableBufferSequence, typename CompletionCondition,
+      typename ReadHandler>
+  inline bool asio_handler_is_continuation(
+      read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    return this_handler->start_ == 0 ? true
+      : boost_asio_handler_cont_helpers::is_continuation(
+          this_handler->handler_);
+  }
+
   template <typename Function, typename AsyncRandomAccessReadDevice,
       typename MutableBufferSequence, typename CompletionCondition,
       typename ReadHandler>
@@ -526,7 +555,7 @@ namespace detail
   inline read_at_op<AsyncRandomAccessReadDevice,
       MutableBufferSequence, CompletionCondition, ReadHandler>
   make_read_at_op(AsyncRandomAccessReadDevice& d,
-      boost::uint64_t offset, const MutableBufferSequence& buffers,
+      uint64_t offset, const MutableBufferSequence& buffers,
       CompletionCondition completion_condition, ReadHandler handler)
   {
     return read_at_op<AsyncRandomAccessReadDevice,
@@ -537,8 +566,10 @@ namespace detail
 
 template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
     typename CompletionCondition, typename ReadHandler>
-inline void async_read_at(AsyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, const MutableBufferSequence& buffers,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read_at(AsyncRandomAccessReadDevice& d,
+    uint64_t offset, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition,
     BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
@@ -546,29 +577,45 @@ inline void async_read_at(AsyncRandomAccessReadDevice& d,
   // not meet the documented type requirements for a ReadHandler.
   BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::make_read_at_op(
-    d, offset, buffers, completion_condition,
-      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
-        boost::system::error_code(), 0, 1);
+  detail::async_result_init<
+    ReadHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+  detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
+    CompletionCondition, BOOST_ASIO_HANDLER_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))>(
+        d, offset, buffers, completion_condition, init.handler)(
+          boost::system::error_code(), 0, 1);
+
+  return init.result.get();
 }
 
 template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
     typename ReadHandler>
-inline void async_read_at(AsyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, const MutableBufferSequence& buffers,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read_at(AsyncRandomAccessReadDevice& d,
+    uint64_t offset, const MutableBufferSequence& buffers,
     BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a ReadHandler.
   BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::make_read_at_op(
-    d, offset, buffers, transfer_all(),
-      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
-        boost::system::error_code(), 0, 1);
+  detail::async_result_init<
+    ReadHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+  detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
+    detail::transfer_all_t, BOOST_ASIO_HANDLER_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))>(
+        d, offset, buffers, transfer_all(), init.handler)(
+          boost::system::error_code(), 0, 1);
+
+  return init.result.get();
 }
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 namespace detail
 {
@@ -579,13 +626,14 @@ namespace detail
   {
   public:
     read_at_streambuf_op(AsyncRandomAccessReadDevice& device,
-        boost::uint64_t offset, basic_streambuf<Allocator>& streambuf,
+        uint64_t offset, basic_streambuf<Allocator>& streambuf,
         CompletionCondition completion_condition, ReadHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         streambuf_(streambuf),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
@@ -597,6 +645,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         streambuf_(other.streambuf_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -607,6 +656,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         streambuf_(other.streambuf_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
     {
@@ -617,7 +667,7 @@ namespace detail
         std::size_t bytes_transferred, int start = 0)
     {
       std::size_t max_size, bytes_available;
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         max_size = this->check_for_completion(ec, total_transferred_);
@@ -642,8 +692,9 @@ namespace detail
 
   //private:
     AsyncRandomAccessReadDevice& device_;
-    boost::uint64_t offset_;
+    uint64_t offset_;
     boost::asio::basic_streambuf<Allocator>& streambuf_;
+    int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
@@ -668,6 +719,17 @@ namespace detail
         pointer, size, this_handler->handler_);
   }
 
+  template <typename AsyncRandomAccessReadDevice, typename Allocator,
+      typename CompletionCondition, typename ReadHandler>
+  inline bool asio_handler_is_continuation(
+      read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    return this_handler->start_ == 0 ? true
+      : boost_asio_handler_cont_helpers::is_continuation(
+          this_handler->handler_);
+  }
+
   template <typename Function, typename AsyncRandomAccessReadDevice,
       typename Allocator, typename CompletionCondition, typename ReadHandler>
   inline void asio_handler_invoke(Function& function,
@@ -687,25 +749,14 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
-
-  template <typename AsyncRandomAccessReadDevice, typename Allocator,
-      typename CompletionCondition, typename ReadHandler>
-  inline read_at_streambuf_op<AsyncRandomAccessReadDevice,
-      Allocator, CompletionCondition, ReadHandler>
-  make_read_at_streambuf_op(AsyncRandomAccessReadDevice& d,
-      boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
-      CompletionCondition completion_condition, ReadHandler handler)
-  {
-    return read_at_streambuf_op<AsyncRandomAccessReadDevice,
-      Allocator, CompletionCondition, ReadHandler>(
-        d, offset, b, completion_condition, handler);
-  }
 } // namespace detail
 
 template <typename AsyncRandomAccessReadDevice, typename Allocator,
     typename CompletionCondition, typename ReadHandler>
-inline void async_read_at(AsyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read_at(AsyncRandomAccessReadDevice& d,
+    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition,
     BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
@@ -713,29 +764,45 @@ inline void async_read_at(AsyncRandomAccessReadDevice& d,
   // not meet the documented type requirements for a ReadHandler.
   BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::make_read_at_streambuf_op(
-    d, offset, b, completion_condition,
-      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
-        boost::system::error_code(), 0, 1);
+  detail::async_result_init<
+    ReadHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+  detail::read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
+    CompletionCondition, BOOST_ASIO_HANDLER_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))>(
+        d, offset, b, completion_condition, init.handler)(
+          boost::system::error_code(), 0, 1);
+
+  return init.result.get();
 }
 
 template <typename AsyncRandomAccessReadDevice, typename Allocator,
     typename ReadHandler>
-inline void async_read_at(AsyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read_at(AsyncRandomAccessReadDevice& d,
+    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
     BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a ReadHandler.
   BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::make_read_at_streambuf_op(
-    d, offset, b, transfer_all(),
-      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
-        boost::system::error_code(), 0, 1);
+  detail::async_result_init<
+    ReadHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+  detail::read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
+    detail::transfer_all_t, BOOST_ASIO_HANDLER_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))>(
+        d, offset, b, transfer_all(), init.handler)(
+          boost::system::error_code(), 0, 1);
+
+  return init.result.get();
 }
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/impl/read_until.hpp b/3rdParty/Boost/src/boost/asio/impl/read_until.hpp
index 1b9a8f3..349c447 100644
--- a/3rdParty/Boost/src/boost/asio/impl/read_until.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/read_until.hpp
@@ -2,7 +2,7 @@
 // impl/read_until.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // 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)
@@ -19,13 +19,14 @@
 #include <string>
 #include <vector>
 #include <utility>
-#include <boost/limits.hpp>
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/buffers_iterator.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_cont_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/limits.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -189,6 +190,8 @@ std::size_t read_until(SyncReadStream& s,
   }
 }
 
+#if defined(BOOST_ASIO_HAS_BOOST_REGEX)
+
 template <typename SyncReadStream, typename Allocator>
 inline std::size_t read_until(SyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr)
@@ -256,11 +259,13 @@ std::size_t read_until(SyncReadStream& s,
   }
 }
 
+#endif // defined(BOOST_ASIO_HAS_BOOST_REGEX)
+
 template <typename SyncReadStream, typename Allocator, typename MatchCondition>
 std::size_t read_until(SyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
     MatchCondition match_condition, boost::system::error_code& ec,
-    typename boost::enable_if<is_match_condition<MatchCondition> >::type*)
+    typename enable_if<is_match_condition<MatchCondition>::value>::type*)
 {
   std::size_t search_position = 0;
   for (;;)
@@ -311,7 +316,7 @@ std::size_t read_until(SyncReadStream& s,
 template <typename SyncReadStream, typename Allocator, typename MatchCondition>
 inline std::size_t read_until(SyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
-    typename boost::enable_if<is_match_condition<MatchCondition> >::type*)
+    typename enable_if<is_match_condition<MatchCondition>::value>::type*)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = read_until(s, b, match_condition, ec);
@@ -331,6 +336,7 @@ namespace detail
       : stream_(stream),
         streambuf_(streambuf),
         delim_(delim),
+        start_(0),
         search_position_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
@@ -341,6 +347,7 @@ namespace detail
       : stream_(other.stream_),
         streambuf_(other.streambuf_),
         delim_(other.delim_),
+        start_(other.start_),
         search_position_(other.search_position_),
         handler_(other.handler_)
     {
@@ -350,6 +357,7 @@ namespace detail
       : stream_(other.stream_),
         streambuf_(other.streambuf_),
         delim_(other.delim_),
+        start_(other.start_),
         search_position_(other.search_position_),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
     {
@@ -361,7 +369,7 @@ namespace detail
     {
       const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
       std::size_t bytes_to_read;
-      switch (start)
+      switch (start_ = start)
       {
       case 1:
         for (;;)
@@ -430,6 +438,7 @@ namespace detail
     AsyncReadStream& stream_;
     boost::asio::basic_streambuf<Allocator>& streambuf_;
     char delim_;
+    int start_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
@@ -452,6 +461,16 @@ namespace detail
         pointer, size, this_handler->handler_);
   }
 
+  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  inline bool asio_handler_is_continuation(
+      read_until_delim_op<AsyncReadStream,
+        Allocator, ReadHandler>* this_handler)
+  {
+    return this_handler->start_ == 0 ? true
+      : boost_asio_handler_cont_helpers::is_continuation(
+          this_handler->handler_);
+  }
+
   template <typename Function, typename AsyncReadStream, typename Allocator,
       typename ReadHandler>
   inline void asio_handler_invoke(Function& function,
@@ -471,20 +490,12 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
-
-  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
-  inline read_until_delim_op<AsyncReadStream, Allocator, ReadHandler>
-  make_read_until_delim_op(AsyncReadStream& s,
-      boost::asio::basic_streambuf<Allocator>& b,
-      char delim, ReadHandler handler)
-  {
-    return read_until_delim_op<AsyncReadStream, Allocator, ReadHandler>(
-        s, b, delim, handler);
-  }
 } // namespace detail
 
 template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
-void async_read_until(AsyncReadStream& s,
+BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b, char delim,
     BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
@@ -492,9 +503,17 @@ void async_read_until(AsyncReadStream& s,
   // not meet the documented type requirements for a ReadHandler.
   BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::make_read_until_delim_op(
-    s, b, delim, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
-      boost::system::error_code(), 0, 1);
+  detail::async_result_init<
+    ReadHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+  detail::read_until_delim_op<AsyncReadStream,
+    Allocator, BOOST_ASIO_HANDLER_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))>(
+        s, b, delim, init.handler)(
+          boost::system::error_code(), 0, 1);
+
+  return init.result.get();
 }
 
 namespace detail
@@ -509,6 +528,7 @@ namespace detail
       : stream_(stream),
         streambuf_(streambuf),
         delim_(delim),
+        start_(0),
         search_position_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
@@ -519,6 +539,7 @@ namespace detail
       : stream_(other.stream_),
         streambuf_(other.streambuf_),
         delim_(other.delim_),
+        start_(other.start_),
         search_position_(other.search_position_),
         handler_(other.handler_)
     {
@@ -528,6 +549,7 @@ namespace detail
       : stream_(other.stream_),
         streambuf_(other.streambuf_),
         delim_(BOOST_ASIO_MOVE_CAST(std::string)(other.delim_)),
+        start_(other.start_),
         search_position_(other.search_position_),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
     {
@@ -539,7 +561,7 @@ namespace detail
     {
       const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
       std::size_t bytes_to_read;
-      switch (start)
+      switch (start_ = start)
       {
       case 1:
         for (;;)
@@ -619,6 +641,7 @@ namespace detail
     AsyncReadStream& stream_;
     boost::asio::basic_streambuf<Allocator>& streambuf_;
     std::string delim_;
+    int start_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
@@ -641,6 +664,16 @@ namespace detail
         pointer, size, this_handler->handler_);
   }
 
+  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  inline bool asio_handler_is_continuation(
+      read_until_delim_string_op<AsyncReadStream,
+        Allocator, ReadHandler>* this_handler)
+  {
+    return this_handler->start_ == 0 ? true
+      : boost_asio_handler_cont_helpers::is_continuation(
+          this_handler->handler_);
+  }
+
   template <typename Function, typename AsyncReadStream,
       typename Allocator, typename ReadHandler>
   inline void asio_handler_invoke(Function& function,
@@ -660,20 +693,12 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
-
-  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
-  inline read_until_delim_string_op<AsyncReadStream, Allocator, ReadHandler>
-  make_read_until_delim_string_op(AsyncReadStream& s,
-      boost::asio::basic_streambuf<Allocator>& b,
-      const std::string& delim, ReadHandler handler)
-  {
-    return read_until_delim_string_op<AsyncReadStream, Allocator, ReadHandler>(
-        s, b, delim, handler);
-  }
 } // namespace detail
 
 template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
-void async_read_until(AsyncReadStream& s,
+BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
     BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
@@ -681,11 +706,21 @@ void async_read_until(AsyncReadStream& s,
   // not meet the documented type requirements for a ReadHandler.
   BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::make_read_until_delim_string_op(
-    s, b, delim, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
-      boost::system::error_code(), 0, 1);
+  detail::async_result_init<
+    ReadHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+  detail::read_until_delim_string_op<AsyncReadStream,
+    Allocator, BOOST_ASIO_HANDLER_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))>(
+        s, b, delim, init.handler)(
+          boost::system::error_code(), 0, 1);
+
+  return init.result.get();
 }
 
+#if defined(BOOST_ASIO_HAS_BOOST_REGEX)
+
 namespace detail
 {
   template <typename AsyncReadStream, typename Allocator,
@@ -699,6 +734,7 @@ namespace detail
       : stream_(stream),
         streambuf_(streambuf),
         expr_(expr),
+        start_(0),
         search_position_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
@@ -709,6 +745,7 @@ namespace detail
       : stream_(other.stream_),
         streambuf_(other.streambuf_),
         expr_(other.expr_),
+        start_(other.start_),
         search_position_(other.search_position_),
         handler_(other.handler_)
     {
@@ -718,6 +755,7 @@ namespace detail
       : stream_(other.stream_),
         streambuf_(other.streambuf_),
         expr_(other.expr_),
+        start_(other.start_),
         search_position_(other.search_position_),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
     {
@@ -729,7 +767,7 @@ namespace detail
     {
       const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
       std::size_t bytes_to_read;
-      switch (start)
+      switch (start_ = start)
       {
       case 1:
         for (;;)
@@ -812,6 +850,7 @@ namespace detail
     AsyncReadStream& stream_;
     boost::asio::basic_streambuf<Allocator>& streambuf_;
     RegEx expr_;
+    int start_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
@@ -836,6 +875,17 @@ namespace detail
         pointer, size, this_handler->handler_);
   }
 
+  template <typename AsyncReadStream, typename Allocator,
+      typename RegEx, typename ReadHandler>
+  inline bool asio_handler_is_continuation(
+      read_until_expr_op<AsyncReadStream,
+        Allocator, RegEx, ReadHandler>* this_handler)
+  {
+    return this_handler->start_ == 0 ? true
+      : boost_asio_handler_cont_helpers::is_continuation(
+          this_handler->handler_);
+  }
+
   template <typename Function, typename AsyncReadStream, typename Allocator,
       typename RegEx, typename ReadHandler>
   inline void asio_handler_invoke(Function& function,
@@ -855,21 +905,12 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
-
-  template <typename AsyncReadStream, typename Allocator,
-      typename RegEx, typename ReadHandler>
-  inline read_until_expr_op<AsyncReadStream, Allocator, RegEx, ReadHandler>
-  make_read_until_expr_op(AsyncReadStream& s,
-      boost::asio::basic_streambuf<Allocator>& b,
-      const RegEx& expr, ReadHandler handler)
-  {
-    return read_until_expr_op<AsyncReadStream, Allocator, RegEx, ReadHandler>(
-        s, b, expr, handler);
-  }
 } // namespace detail
 
 template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
-void async_read_until(AsyncReadStream& s,
+BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
     BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
@@ -877,11 +918,21 @@ void async_read_until(AsyncReadStream& s,
   // not meet the documented type requirements for a ReadHandler.
   BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::make_read_until_expr_op(
-    s, b, expr, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
-      boost::system::error_code(), 0, 1);
+  detail::async_result_init<
+    ReadHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+  detail::read_until_expr_op<AsyncReadStream, Allocator,
+    boost::regex, BOOST_ASIO_HANDLER_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))>(
+        s, b, expr, init.handler)(
+          boost::system::error_code(), 0, 1);
+
+  return init.result.get();
 }
 
+#endif // defined(BOOST_ASIO_HAS_BOOST_REGEX)
+
 namespace detail
 {
   template <typename AsyncReadStream, typename Allocator,
@@ -895,6 +946,7 @@ namespace detail
       : stream_(stream),
         streambuf_(streambuf),
         match_condition_(match_condition),
+        start_(0),
         search_position_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
@@ -905,6 +957,7 @@ namespace detail
       : stream_(other.stream_),
         streambuf_(other.streambuf_),
         match_condition_(other.match_condition_),
+        start_(other.start_),
         search_position_(other.search_position_),
         handler_(other.handler_)
     {
@@ -914,6 +967,7 @@ namespace detail
       : stream_(other.stream_),
         streambuf_(other.streambuf_),
         match_condition_(other.match_condition_),
+        start_(other.start_),
         search_position_(other.search_position_),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
     {
@@ -925,7 +979,7 @@ namespace detail
     {
       const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
       std::size_t bytes_to_read;
-      switch (start)
+      switch (start_ = start)
       {
       case 1:
         for (;;)
@@ -1004,6 +1058,7 @@ namespace detail
     AsyncReadStream& stream_;
     boost::asio::basic_streambuf<Allocator>& streambuf_;
     MatchCondition match_condition_;
+    int start_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
@@ -1028,6 +1083,17 @@ namespace detail
         pointer, size, this_handler->handler_);
   }
 
+  template <typename AsyncReadStream, typename Allocator,
+      typename MatchCondition, typename ReadHandler>
+  inline bool asio_handler_is_continuation(
+      read_until_match_op<AsyncReadStream,
+        Allocator, MatchCondition, ReadHandler>* this_handler)
+  {
+    return this_handler->start_ == 0 ? true
+      : boost_asio_handler_cont_helpers::is_continuation(
+          this_handler->handler_);
+  }
+
   template <typename Function, typename AsyncReadStream, typename Allocator,
       typename MatchCondition, typename ReadHandler>
   inline void asio_handler_invoke(Function& function,
@@ -1047,35 +1113,32 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
-
-  template <typename AsyncReadStream, typename Allocator,
-      typename MatchCondition, typename ReadHandler>
-  inline read_until_match_op<AsyncReadStream, Allocator,
-      MatchCondition, ReadHandler>
-  make_read_until_match_op(AsyncReadStream& s,
-      boost::asio::basic_streambuf<Allocator>& b,
-      MatchCondition match_condition, ReadHandler handler)
-  {
-    return read_until_match_op<AsyncReadStream,
-      Allocator, MatchCondition, ReadHandler>(
-        s, b, match_condition, handler);
-  }
 } // namespace detail
 
 template <typename AsyncReadStream, typename Allocator,
     typename MatchCondition, typename ReadHandler>
-void async_read_until(AsyncReadStream& s,
+BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
     MatchCondition match_condition, BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
-    typename boost::enable_if<is_match_condition<MatchCondition> >::type*)
+    typename enable_if<is_match_condition<MatchCondition>::value>::type*)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a ReadHandler.
   BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::make_read_until_match_op(
-    s, b, match_condition, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
-      boost::system::error_code(), 0, 1);
+  detail::async_result_init<
+    ReadHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+  detail::read_until_match_op<AsyncReadStream, Allocator,
+    MatchCondition, BOOST_ASIO_HANDLER_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))>(
+        s, b, match_condition, init.handler)(
+          boost::system::error_code(), 0, 1);
+
+  return init.result.get();
 }
 
 } // namespace asio
diff --git a/3rdParty/Boost/src/boost/asio/impl/serial_port_base.hpp b/3rdParty/Boost/src/boost/asio/impl/serial_port_base.hpp
index 3066045..92be00d 100644
--- a/3rdParty/Boost/src/boost/asio/impl/serial_port_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/serial_port_base.hpp
@@ -2,7 +2,7 @@
 // impl/serial_port_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/3rdParty/Boost/src/boost/asio/impl/serial_port_base.ipp b/3rdParty/Boost/src/boost/asio/impl/serial_port_base.ipp
index 0344fa5..51f66c1 100644
--- a/3rdParty/Boost/src/boost/asio/impl/serial_port_base.ipp
+++ b/3rdParty/Boost/src/boost/asio/impl/serial_port_base.ipp
@@ -2,7 +2,7 @@
 // impl/serial_port_base.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -21,13 +21,13 @@
 #if defined(BOOST_ASIO_HAS_SERIAL_PORT)
 
 #include <stdexcept>
-#include <boost/throw_exception.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/serial_port_base.hpp>
+#include <boost/asio/detail/throw_exception.hpp>
 
 #if defined(GENERATING_DOCUMENTATION)
 # define BOOST_ASIO_OPTION_STORAGE implementation_defined
-#elif defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 # define BOOST_ASIO_OPTION_STORAGE DCB
 #else
 # define BOOST_ASIO_OPTION_STORAGE termios
@@ -41,7 +41,7 @@ namespace asio {
 boost::system::error_code serial_port_base::baud_rate::store(
     BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec) const
 {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   storage.BaudRate = value_;
 #else
   speed_t baud;
@@ -111,7 +111,6 @@ boost::system::error_code serial_port_base::baud_rate::store(
   case 4000000: baud = B4000000; break;
 # endif
   default:
-    baud = B0;
     ec = boost::asio::error::invalid_argument;
     return ec;
   }
@@ -129,7 +128,7 @@ boost::system::error_code serial_port_base::baud_rate::store(
 boost::system::error_code serial_port_base::baud_rate::load(
     const BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec)
 {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   value_ = storage.BaudRate;
 #else
   speed_t baud = ::cfgetospeed(&storage);
@@ -215,14 +214,14 @@ serial_port_base::flow_control::flow_control(
   if (t != none && t != software && t != hardware)
   {
     std::out_of_range ex("invalid flow_control value");
-    boost::throw_exception(ex);
+    boost::asio::detail::throw_exception(ex);
   }
 }
 
 boost::system::error_code serial_port_base::flow_control::store(
     BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec) const
 {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   storage.fOutxCtsFlow = FALSE;
   storage.fOutxDsrFlow = FALSE;
   storage.fTXContinueOnXoff = TRUE;
@@ -289,7 +288,7 @@ boost::system::error_code serial_port_base::flow_control::store(
 boost::system::error_code serial_port_base::flow_control::load(
     const BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec)
 {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   if (storage.fOutX && storage.fInX)
   {
     value_ = software;
@@ -333,14 +332,14 @@ serial_port_base::parity::parity(serial_port_base::parity::type t)
   if (t != none && t != odd && t != even)
   {
     std::out_of_range ex("invalid parity value");
-    boost::throw_exception(ex);
+    boost::asio::detail::throw_exception(ex);
   }
 }
 
 boost::system::error_code serial_port_base::parity::store(
     BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec) const
 {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   switch (value_)
   {
   case none:
@@ -387,7 +386,7 @@ boost::system::error_code serial_port_base::parity::store(
 boost::system::error_code serial_port_base::parity::load(
     const BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec)
 {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   if (storage.Parity == EVENPARITY)
   {
     value_ = even;
@@ -428,14 +427,14 @@ serial_port_base::stop_bits::stop_bits(
   if (t != one && t != onepointfive && t != two)
   {
     std::out_of_range ex("invalid stop_bits value");
-    boost::throw_exception(ex);
+    boost::asio::detail::throw_exception(ex);
   }
 }
 
 boost::system::error_code serial_port_base::stop_bits::store(
     BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec) const
 {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   switch (value_)
   {
   case one:
@@ -471,7 +470,7 @@ boost::system::error_code serial_port_base::stop_bits::store(
 boost::system::error_code serial_port_base::stop_bits::load(
     const BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec)
 {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   if (storage.StopBits == ONESTOPBIT)
   {
     value_ = one;
@@ -501,14 +500,14 @@ serial_port_base::character_size::character_size(unsigned int t)
   if (t < 5 || t > 8)
   {
     std::out_of_range ex("invalid character_size value");
-    boost::throw_exception(ex);
+    boost::asio::detail::throw_exception(ex);
   }
 }
 
 boost::system::error_code serial_port_base::character_size::store(
     BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec) const
 {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   storage.ByteSize = value_;
 #else
   storage.c_cflag &= ~CSIZE;
@@ -528,7 +527,7 @@ boost::system::error_code serial_port_base::character_size::store(
 boost::system::error_code serial_port_base::character_size::load(
     const BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec)
 {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   value_ = storage.ByteSize;
 #else
   if ((storage.c_cflag & CSIZE) == CS5) { value_ = 5; }
diff --git a/3rdParty/Boost/src/boost/asio/impl/write.hpp b/3rdParty/Boost/src/boost/asio/impl/write.hpp
index 61422e4..ef0c092 100644
--- a/3rdParty/Boost/src/boost/asio/impl/write.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/write.hpp
@@ -2,7 +2,7 @@
 // impl/write.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // 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)
@@ -23,6 +23,7 @@
 #include <boost/asio/detail/consuming_buffers.hpp>
 #include <boost/asio/detail/dependent_type.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_cont_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
@@ -81,7 +82,7 @@ inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
   return bytes_transferred;
 }
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 template <typename SyncWriteStream, typename Allocator,
     typename CompletionCondition>
@@ -124,7 +125,7 @@ inline std::size_t write(SyncWriteStream& s,
   return bytes_transferred;
 }
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 namespace detail
 {
@@ -140,6 +141,7 @@ namespace detail
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
@@ -150,6 +152,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -159,6 +162,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
     {
@@ -168,7 +172,7 @@ namespace detail
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         buffers_.prepare(this->check_for_completion(ec, total_transferred_));
@@ -193,6 +197,7 @@ namespace detail
     AsyncWriteStream& stream_;
     boost::asio::detail::consuming_buffers<
       const_buffer, ConstBufferSequence> buffers_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
@@ -212,6 +217,7 @@ namespace detail
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffer_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
@@ -222,6 +228,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffer_(other.buffer_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -231,6 +238,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffer_(other.buffer_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
     {
@@ -241,7 +249,7 @@ namespace detail
         std::size_t bytes_transferred, int start = 0)
     {
       std::size_t n = 0;
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
@@ -265,6 +273,7 @@ namespace detail
   //private:
     AsyncWriteStream& stream_;
     boost::asio::mutable_buffer buffer_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
@@ -284,6 +293,7 @@ namespace detail
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffer_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
@@ -294,6 +304,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffer_(other.buffer_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -303,6 +314,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffer_(other.buffer_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
     {
@@ -313,7 +325,7 @@ namespace detail
         std::size_t bytes_transferred, int start = 0)
     {
       std::size_t n = 0;
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
@@ -337,6 +349,7 @@ namespace detail
   //private:
     AsyncWriteStream& stream_;
     boost::asio::const_buffer buffer_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
@@ -354,6 +367,7 @@ namespace detail
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
@@ -364,6 +378,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -373,6 +388,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
     {
@@ -389,7 +405,7 @@ namespace detail
       std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
       std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
       std::size_t n = 0;
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
@@ -416,6 +432,7 @@ namespace detail
   //private:
     AsyncWriteStream& stream_;
     boost::array<Elem, 2> buffers_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
@@ -435,6 +452,7 @@ namespace detail
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
@@ -445,6 +463,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -454,6 +473,7 @@ namespace detail
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
     {
@@ -470,7 +490,7 @@ namespace detail
       std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
       std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
       std::size_t n = 0;
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
@@ -497,6 +517,7 @@ namespace detail
   //private:
     AsyncWriteStream& stream_;
     std::array<Elem, 2> buffers_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
@@ -523,6 +544,17 @@ namespace detail
         pointer, size, this_handler->handler_);
   }
 
+  template <typename AsyncWriteStream, typename ConstBufferSequence,
+      typename CompletionCondition, typename WriteHandler>
+  inline bool asio_handler_is_continuation(
+      write_op<AsyncWriteStream, ConstBufferSequence,
+        CompletionCondition, WriteHandler>* this_handler)
+  {
+    return this_handler->start_ == 0 ? true
+      : boost_asio_handler_cont_helpers::is_continuation(
+          this_handler->handler_);
+  }
+
   template <typename Function, typename AsyncWriteStream,
       typename ConstBufferSequence, typename CompletionCondition,
       typename WriteHandler>
@@ -544,22 +576,13 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
-
-  template <typename AsyncWriteStream, typename ConstBufferSequence,
-      typename CompletionCondition, typename WriteHandler>
-  inline write_op<AsyncWriteStream, ConstBufferSequence,
-      CompletionCondition, WriteHandler>
-  make_write_op(AsyncWriteStream& s, const ConstBufferSequence& buffers,
-      CompletionCondition completion_condition, WriteHandler handler)
-  {
-    return write_op<AsyncWriteStream, ConstBufferSequence, CompletionCondition,
-      WriteHandler>(s, buffers, completion_condition, handler);
-  }
 } // namespace detail
 
 template <typename AsyncWriteStream, typename ConstBufferSequence,
   typename CompletionCondition, typename WriteHandler>
-inline void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (boost::system::error_code, std::size_t))
+async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition,
     BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
@@ -567,27 +590,44 @@ inline void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
   // not meet the documented type requirements for a WriteHandler.
   BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-  detail::make_write_op(
-    s, buffers, completion_condition,
-      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))(
-        boost::system::error_code(), 0, 1);
+  detail::async_result_init<
+    WriteHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
+  detail::write_op<AsyncWriteStream, ConstBufferSequence,
+    CompletionCondition, BOOST_ASIO_HANDLER_TYPE(
+      WriteHandler, void (boost::system::error_code, std::size_t))>(
+        s, buffers, completion_condition, init.handler)(
+          boost::system::error_code(), 0, 1);
+
+  return init.result.get();
 }
 
 template <typename AsyncWriteStream, typename ConstBufferSequence,
     typename WriteHandler>
-inline void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (boost::system::error_code, std::size_t))
+async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
     BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a WriteHandler.
   BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-  detail::make_write_op(
-    s, buffers, transfer_all(), BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))(
-      boost::system::error_code(), 0, 1);
+  detail::async_result_init<
+    WriteHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
+  detail::write_op<AsyncWriteStream, ConstBufferSequence,
+    detail::transfer_all_t, BOOST_ASIO_HANDLER_TYPE(
+      WriteHandler, void (boost::system::error_code, std::size_t))>(
+        s, buffers, transfer_all(), init.handler)(
+          boost::system::error_code(), 0, 1);
+
+  return init.result.get();
 }
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 namespace detail
 {
@@ -644,6 +684,14 @@ namespace detail
         pointer, size, this_handler->handler_);
   }
 
+  template <typename Allocator, typename WriteHandler>
+  inline bool asio_handler_is_continuation(
+      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+  {
+    return boost_asio_handler_cont_helpers::is_continuation(
+        this_handler->handler_);
+  }
+
   template <typename Function, typename Allocator, typename WriteHandler>
   inline void asio_handler_invoke(Function& function,
       write_streambuf_handler<Allocator, WriteHandler>* this_handler)
@@ -659,19 +707,13 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
-
-  template <typename Allocator, typename WriteHandler>
-  inline write_streambuf_handler<Allocator, WriteHandler>
-  make_write_streambuf_handler(
-      boost::asio::basic_streambuf<Allocator>& b, WriteHandler handler)
-  {
-    return write_streambuf_handler<Allocator, WriteHandler>(b, handler);
-  }
 } // namespace detail
 
 template <typename AsyncWriteStream, typename Allocator,
     typename CompletionCondition, typename WriteHandler>
-inline void async_write(AsyncWriteStream& s,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (boost::system::error_code, std::size_t))
+async_write(AsyncWriteStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition,
     BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
@@ -680,13 +722,22 @@ inline void async_write(AsyncWriteStream& s,
   // not meet the documented type requirements for a WriteHandler.
   BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
+  detail::async_result_init<
+    WriteHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
   async_write(s, b.data(), completion_condition,
-      detail::make_write_streambuf_handler(
-        b, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)));
+    detail::write_streambuf_handler<Allocator, BOOST_ASIO_HANDLER_TYPE(
+      WriteHandler, void (boost::system::error_code, std::size_t))>(
+        b, init.handler));
+
+  return init.result.get();
 }
 
 template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
-inline void async_write(AsyncWriteStream& s,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (boost::system::error_code, std::size_t))
+async_write(AsyncWriteStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
     BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
@@ -694,12 +745,19 @@ inline void async_write(AsyncWriteStream& s,
   // not meet the documented type requirements for a WriteHandler.
   BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
+  detail::async_result_init<
+    WriteHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
   async_write(s, b.data(), transfer_all(),
-      detail::make_write_streambuf_handler(
-        b, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)));
+    detail::write_streambuf_handler<Allocator, BOOST_ASIO_HANDLER_TYPE(
+      WriteHandler, void (boost::system::error_code, std::size_t))>(
+        b, init.handler));
+
+  return init.result.get();
 }
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/impl/write_at.hpp b/3rdParty/Boost/src/boost/asio/impl/write_at.hpp
index acba02f..0d0dc4b 100644
--- a/3rdParty/Boost/src/boost/asio/impl/write_at.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/write_at.hpp
@@ -2,7 +2,7 @@
 // impl/write_at.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // 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)
@@ -23,6 +23,7 @@
 #include <boost/asio/detail/consuming_buffers.hpp>
 #include <boost/asio/detail/dependent_type.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_cont_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
@@ -35,7 +36,7 @@ namespace asio {
 template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
     typename CompletionCondition>
 std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    boost::uint64_t offset, const ConstBufferSequence& buffers,
+    uint64_t offset, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition, boost::system::error_code& ec)
 {
   ec = boost::system::error_code();
@@ -58,7 +59,7 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d,
 
 template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
 inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    boost::uint64_t offset, const ConstBufferSequence& buffers)
+    uint64_t offset, const ConstBufferSequence& buffers)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = write_at(
@@ -69,7 +70,7 @@ inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
 
 template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
 inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    boost::uint64_t offset, const ConstBufferSequence& buffers,
+    uint64_t offset, const ConstBufferSequence& buffers,
     boost::system::error_code& ec)
 {
   return write_at(d, offset, buffers, transfer_all(), ec);
@@ -78,7 +79,7 @@ inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
 template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
     typename CompletionCondition>
 inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    boost::uint64_t offset, const ConstBufferSequence& buffers,
+    uint64_t offset, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition)
 {
   boost::system::error_code ec;
@@ -88,12 +89,12 @@ inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
   return bytes_transferred;
 }
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 template <typename SyncRandomAccessWriteDevice, typename Allocator,
     typename CompletionCondition>
 std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition, boost::system::error_code& ec)
 {
   std::size_t bytes_transferred = write_at(
@@ -104,7 +105,7 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d,
 
 template <typename SyncRandomAccessWriteDevice, typename Allocator>
 inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b)
+    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = write_at(d, offset, b, transfer_all(), ec);
@@ -114,7 +115,7 @@ inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
 
 template <typename SyncRandomAccessWriteDevice, typename Allocator>
 inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
     boost::system::error_code& ec)
 {
   return write_at(d, offset, b, transfer_all(), ec);
@@ -123,7 +124,7 @@ inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
 template <typename SyncRandomAccessWriteDevice, typename Allocator,
     typename CompletionCondition>
 inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition)
 {
   boost::system::error_code ec;
@@ -133,7 +134,7 @@ inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
   return bytes_transferred;
 }
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 namespace detail
 {
@@ -144,13 +145,14 @@ namespace detail
   {
   public:
     write_at_op(AsyncRandomAccessWriteDevice& device,
-        boost::uint64_t offset, const ConstBufferSequence& buffers,
+        uint64_t offset, const ConstBufferSequence& buffers,
         CompletionCondition completion_condition, WriteHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffers_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
@@ -162,6 +164,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -172,6 +175,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
     {
@@ -181,7 +185,7 @@ namespace detail
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         buffers_.prepare(this->check_for_completion(ec, total_transferred_));
@@ -205,9 +209,10 @@ namespace detail
 
   //private:
     AsyncRandomAccessWriteDevice& device_;
-    boost::uint64_t offset_;
+    uint64_t offset_;
     boost::asio::detail::consuming_buffers<
       const_buffer, ConstBufferSequence> buffers_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
@@ -220,7 +225,7 @@ namespace detail
   {
   public:
     write_at_op(AsyncRandomAccessWriteDevice& device,
-        boost::uint64_t offset, const boost::asio::mutable_buffers_1& buffers,
+        uint64_t offset, const boost::asio::mutable_buffers_1& buffers,
         CompletionCondition completion_condition,
         WriteHandler& handler)
       : detail::base_from_completion_cond<
@@ -228,6 +233,7 @@ namespace detail
         device_(device),
         offset_(offset),
         buffer_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
@@ -239,6 +245,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         buffer_(other.buffer_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -249,6 +256,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         buffer_(other.buffer_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
     {
@@ -259,7 +267,7 @@ namespace detail
         std::size_t bytes_transferred, int start = 0)
     {
       std::size_t n = 0;
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
@@ -282,8 +290,9 @@ namespace detail
 
   //private:
     AsyncRandomAccessWriteDevice& device_;
-    boost::uint64_t offset_;
+    uint64_t offset_;
     boost::asio::mutable_buffer buffer_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
@@ -296,7 +305,7 @@ namespace detail
   {
   public:
     write_at_op(AsyncRandomAccessWriteDevice& device,
-        boost::uint64_t offset, const boost::asio::const_buffers_1& buffers,
+        uint64_t offset, const boost::asio::const_buffers_1& buffers,
         CompletionCondition completion_condition,
         WriteHandler& handler)
       : detail::base_from_completion_cond<
@@ -304,6 +313,7 @@ namespace detail
         device_(device),
         offset_(offset),
         buffer_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
@@ -315,6 +325,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         buffer_(other.buffer_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -325,6 +336,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         buffer_(other.buffer_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
     {
@@ -335,7 +347,7 @@ namespace detail
         std::size_t bytes_transferred, int start = 0)
     {
       std::size_t n = 0;
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
@@ -358,8 +370,9 @@ namespace detail
 
   //private:
     AsyncRandomAccessWriteDevice& device_;
-    boost::uint64_t offset_;
+    uint64_t offset_;
     boost::asio::const_buffer buffer_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
@@ -372,13 +385,14 @@ namespace detail
   {
   public:
     write_at_op(AsyncRandomAccessWriteDevice& device,
-        boost::uint64_t offset, const boost::array<Elem, 2>& buffers,
+        uint64_t offset, const boost::array<Elem, 2>& buffers,
         CompletionCondition completion_condition, WriteHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffers_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
@@ -390,6 +404,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -400,6 +415,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
     {
@@ -416,7 +432,7 @@ namespace detail
       std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
       std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
       std::size_t n = 0;
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
@@ -443,8 +459,9 @@ namespace detail
 
   //private:
     AsyncRandomAccessWriteDevice& device_;
-    boost::uint64_t offset_;
+    uint64_t offset_;
     boost::array<Elem, 2> buffers_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
@@ -459,13 +476,14 @@ namespace detail
   {
   public:
     write_at_op(AsyncRandomAccessWriteDevice& device,
-        boost::uint64_t offset, const std::array<Elem, 2>& buffers,
+        uint64_t offset, const std::array<Elem, 2>& buffers,
         CompletionCondition completion_condition, WriteHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffers_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
@@ -477,6 +495,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
@@ -487,6 +506,7 @@ namespace detail
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
     {
@@ -503,7 +523,7 @@ namespace detail
       std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
       std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
       std::size_t n = 0;
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
@@ -530,8 +550,9 @@ namespace detail
 
   //private:
     AsyncRandomAccessWriteDevice& device_;
-    boost::uint64_t offset_;
+    uint64_t offset_;
     std::array<Elem, 2> buffers_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
@@ -558,6 +579,17 @@ namespace detail
         pointer, size, this_handler->handler_);
   }
 
+  template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
+      typename CompletionCondition, typename WriteHandler>
+  inline bool asio_handler_is_continuation(
+      write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
+        CompletionCondition, WriteHandler>* this_handler)
+  {
+    return this_handler->start_ == 0 ? true
+      : boost_asio_handler_cont_helpers::is_continuation(
+          this_handler->handler_);
+  }
+
   template <typename Function, typename AsyncRandomAccessWriteDevice,
       typename ConstBufferSequence, typename CompletionCondition,
       typename WriteHandler>
@@ -585,7 +617,7 @@ namespace detail
   inline write_at_op<AsyncRandomAccessWriteDevice,
       ConstBufferSequence, CompletionCondition, WriteHandler>
   make_write_at_op(AsyncRandomAccessWriteDevice& d,
-      boost::uint64_t offset, const ConstBufferSequence& buffers,
+      uint64_t offset, const ConstBufferSequence& buffers,
       CompletionCondition completion_condition, WriteHandler handler)
   {
     return write_at_op<AsyncRandomAccessWriteDevice,
@@ -596,8 +628,10 @@ namespace detail
 
 template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
     typename CompletionCondition, typename WriteHandler>
-inline void async_write_at(AsyncRandomAccessWriteDevice& d,
-    boost::uint64_t offset, const ConstBufferSequence& buffers,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (boost::system::error_code, std::size_t))
+async_write_at(AsyncRandomAccessWriteDevice& d,
+    uint64_t offset, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition,
     BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
@@ -605,29 +639,45 @@ inline void async_write_at(AsyncRandomAccessWriteDevice& d,
   // not meet the documented type requirements for a WriteHandler.
   BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-  detail::make_write_at_op(
-    d, offset, buffers, completion_condition,
-      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))(
-        boost::system::error_code(), 0, 1);
+  detail::async_result_init<
+    WriteHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
+  detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
+    CompletionCondition, BOOST_ASIO_HANDLER_TYPE(
+      WriteHandler, void (boost::system::error_code, std::size_t))>(
+        d, offset, buffers, completion_condition, init.handler)(
+          boost::system::error_code(), 0, 1);
+
+  return init.result.get();
 }
 
 template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
     typename WriteHandler>
-inline void async_write_at(AsyncRandomAccessWriteDevice& d,
-    boost::uint64_t offset, const ConstBufferSequence& buffers,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (boost::system::error_code, std::size_t))
+async_write_at(AsyncRandomAccessWriteDevice& d,
+    uint64_t offset, const ConstBufferSequence& buffers,
     BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a WriteHandler.
   BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-  detail::make_write_at_op(
-    d, offset, buffers, transfer_all(),
-      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))(
-        boost::system::error_code(), 0, 1);
+  detail::async_result_init<
+    WriteHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
+  detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
+    detail::transfer_all_t, BOOST_ASIO_HANDLER_TYPE(
+      WriteHandler, void (boost::system::error_code, std::size_t))>(
+        d, offset, buffers, transfer_all(), init.handler)(
+          boost::system::error_code(), 0, 1);
+
+  return init.result.get();
 }
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 namespace detail
 {
@@ -685,6 +735,14 @@ namespace detail
         pointer, size, this_handler->handler_);
   }
 
+  template <typename Allocator, typename WriteHandler>
+  inline bool asio_handler_is_continuation(
+      write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
+  {
+    return boost_asio_handler_cont_helpers::is_continuation(
+        this_handler->handler_);
+  }
+
   template <typename Function, typename Allocator, typename WriteHandler>
   inline void asio_handler_invoke(Function& function,
       write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
@@ -712,8 +770,10 @@ namespace detail
 
 template <typename AsyncRandomAccessWriteDevice, typename Allocator,
     typename CompletionCondition, typename WriteHandler>
-inline void async_write_at(AsyncRandomAccessWriteDevice& d,
-    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (boost::system::error_code, std::size_t))
+async_write_at(AsyncRandomAccessWriteDevice& d,
+    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition,
     BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
@@ -721,27 +781,43 @@ inline void async_write_at(AsyncRandomAccessWriteDevice& d,
   // not meet the documented type requirements for a WriteHandler.
   BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
+  detail::async_result_init<
+    WriteHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
   async_write_at(d, offset, b.data(), completion_condition,
-      detail::make_write_at_streambuf_op(
-        b, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)));
+    detail::write_at_streambuf_op<Allocator, BOOST_ASIO_HANDLER_TYPE(
+      WriteHandler, void (boost::system::error_code, std::size_t))>(
+        b, init.handler));
+
+  return init.result.get();
 }
 
 template <typename AsyncRandomAccessWriteDevice, typename Allocator,
     typename WriteHandler>
-inline void async_write_at(AsyncRandomAccessWriteDevice& d,
-    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+inline BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (boost::system::error_code, std::size_t))
+async_write_at(AsyncRandomAccessWriteDevice& d,
+    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
     BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a WriteHandler.
   BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
+  detail::async_result_init<
+    WriteHandler, void (boost::system::error_code, std::size_t)> init(
+      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
   async_write_at(d, offset, b.data(), transfer_all(),
-      detail::make_write_at_streambuf_op(
-        b, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)));
+    detail::write_at_streambuf_op<Allocator, BOOST_ASIO_HANDLER_TYPE(
+      WriteHandler, void (boost::system::error_code, std::size_t))>(
+        b, init.handler));
+
+  return init.result.get();
 }
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 } // namespace asio
 } // namespace boost